puppet 6.11.1-x86-mingw32 → 6.16.0-x86-mingw32

data/spec/unit/forge_spec.rb

@@ -1,88 +1,13 @@
 require 'spec_helper'
-require 'puppet/forge'
+require 'spec_helper'
 require 'net/http'
+require 'puppet/forge'
 require 'puppet/module_tool'
 
 describe Puppet::Forge do
+
   let(:http_response) do
-  <<-EOF
-    {
-      "pagination": {
-        "limit": 1,
-        "offset": 0,
-        "first": "/v3/modules?limit=1&offset=0",
-        "previous": null,
-        "current": "/v3/modules?limit=1&offset=0",
-        "next": null,
-        "total": 1832
-      },
-      "results": [
-        {
-          "uri": "/v3/modules/puppetlabs-bacula",
-          "name": "bacula",
-          "downloads": 640274,
-          "created_at": "2011-05-24 18:34:58 -0700",
-          "updated_at": "2013-12-03 15:24:20 -0800",
-          "owner": {
-            "uri": "/v3/users/puppetlabs",
-            "username": "puppetlabs",
-            "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
-          },
-          "current_release": {
-            "uri": "/v3/releases/puppetlabs-bacula-0.0.2",
-            "module": {
-              "uri": "/v3/modules/puppetlabs-bacula",
-              "name": "bacula",
-              "owner": {
-                "uri": "/v3/users/puppetlabs",
-                "username": "puppetlabs",
-                "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
-              }
-            },
-            "version": "0.0.2",
-            "metadata": {
-              "types": [],
-              "license": "Apache 2.0",
-              "checksums": { },
-              "version": "0.0.2",
-              "source": "git://github.com/puppetlabs/puppetlabs-bacula.git",
-              "project_page": "https://github.com/puppetlabs/puppetlabs-bacula",
-              "summary": "bacula",
-              "dependencies": [ ],
-              "author": "puppetlabs",
-              "name": "puppetlabs-bacula"
-            },
-            "tags": [
-              "backup",
-              "bacula"
-            ],
-            "file_uri": "/v3/files/puppetlabs-bacula-0.0.2.tar.gz",
-            "file_size": 67586,
-            "file_md5": "bbf919d7ee9d278d2facf39c25578bf8",
-            "downloads": 565041,
-            "readme": "",
-            "changelog": "",
-            "license": "",
-            "created_at": "2013-05-13 08:31:19 -0700",
-            "updated_at": "2013-05-13 08:31:19 -0700",
-            "deleted_at": null
-          },
-          "releases": [
-            {
-              "uri": "/v3/releases/puppetlabs-bacula-0.0.2",
-              "version": "0.0.2"
-            },
-            {
-              "uri": "/v3/releases/puppetlabs-bacula-0.0.1",
-              "version": "0.0.1"
-            }
-          ],
-          "homepage_url": "https://github.com/puppetlabs/puppetlabs-bacula",
-          "issues_url": "https://projects.puppetlabs.com/projects/bacula/issues"
-        }
-      ]
-    }
-  EOF
+    File.read(my_fixture('bacula.json'))
   end
 
   let(:search_results) do
@@ -99,76 +24,84 @@ describe Puppet::Forge do
     end
   end
 
-  let(:forge) { Puppet::Forge.new }
-
-  def repository_responds_with(response, &block)
-    if block_given?
-      allow_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request, &block).and_return(response)
-    else
-      allow_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request).and_return(response)
-    end
+  let(:release_response) do
+    releases = JSON.parse(http_response)
+    releases['results'] = []
+    JSON.dump(releases)
   end
 
+  let(:forge) { Puppet::Forge.new }
+
   it "returns a list of matches from the forge when there are matches for the search term" do
-    repository_responds_with(double(:body => http_response, :code => '200'))
+    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=bacula").to_return(status: 200, body: http_response)
+
     expect(forge.search('bacula')).to eq(search_results)
   end
 
   context "when module_groups are defined" do
-    let(:release_response) do
-      releases = JSON.parse(http_response)
-      releases['results'] = []
-      JSON.dump(releases)
-    end
-
     before :each do
-      repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo/}
       Puppet[:module_groups] = "foo"
     end
 
     it "passes module_groups with search" do
+      stub_request(:get, "https://forgeapi.puppet.com/v3/modules")
+        .with(query: hash_including("module_groups" => "foo"))
+        .to_return(status: 200, body: release_response)
+
       forge.search('bacula')
     end
 
     it "passes module_groups with fetch" do
+      stub_request(:get, "https://forgeapi.puppet.com/v3/releases")
+        .with(query: hash_including("module_groups" => "foo"))
+        .to_return(status: 200, body: release_response)
+
       forge.fetch('puppetlabs-bacula')
     end
   end
 
   # See PUP-8008
   context "when multiple module_groups are defined" do
-    let(:release_response) do
-      releases = JSON.parse(http_response)
-      releases['results'] = []
-      JSON.dump(releases)
-    end
-
     context "with space seperator" do
       before :each do
-        repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo bar/}
         Puppet[:module_groups] = "foo bar"
       end
 
       it "passes module_groups with search" do
+        stub_request(:get, %r{forgeapi.puppet.com/v3/modules}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: release_response)
+
         forge.search('bacula')
       end
 
       it "passes module_groups with fetch" do
+        stub_request(:get, %r{forgeapi.puppet.com/v3/releases}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: release_response)
+
         forge.fetch('puppetlabs-bacula')
       end
     end
 
     context "with plus seperator" do
       before :each do
-        repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo bar/}
         Puppet[:module_groups] = "foo+bar"
       end
 
       it "passes module_groups with search" do
+        stub_request(:get, %r{forgeapi.puppet.com/v3/modules}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: release_response)
+
         forge.search('bacula')
       end
 
       it "passes module_groups with fetch" do
+        stub_request(:get, %r{forgeapi.puppet.com/v3/releases}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: release_response)
+
         forge.fetch('puppetlabs-bacula')
       end
     end
@@ -176,10 +109,10 @@ describe Puppet::Forge do
     # See PUP-8008
     context "when there are multiple pages of results" do
       before(:each) do
-        expect_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request) {|_, uri| uri =~ /module_groups=foo bar/ && uri !=~ /offset/ }.and_return(double(:body => first_page, :code => '200'))
-
-        # Request for second page should not have module_groups already encoded
-        expect_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request) {|_, uri| uri =~ /module_groups=foo bar/ && uri =~ /offset=1/ }.and_return(double(:body => last_page, :code => '200'))
+        stub_request(:get, %r{forgeapi.puppet.com}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: first_page)
+          .to_return(status: 200, body: last_page)
       end
 
       context "with space seperator" do
@@ -242,7 +175,7 @@ describe Puppet::Forge do
 
   context "when the connection to the forge fails" do
     before :each do
-      repository_responds_with(double(:body => '{}', :code => '404', :message => "not found"))
+      stub_request(:get, /forgeapi.puppet.com/).to_return(status: [404, 'not found'])
     end
 
     it "raises an error for search" do
@@ -255,25 +188,22 @@ describe Puppet::Forge do
   end
 
   context "when the API responds with an error" do
-    before :each do
-      repository_responds_with(double(:body => '{"error":"invalid module"}', :code => '410', :message => "Gone"))
-    end
-
     it "raises an error for fetch" do
+      stub_request(:get, /forgeapi.puppet.com/).to_return(status: [410, 'Gone'], body: '{"error":"invalid module"}')
+
       expect { forge.fetch('puppetlabs/bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Request to Puppet Forge failed. Detail: 410 Gone."
     end
   end
 
   context "when the forge returns a module with unparseable dependencies" do
-    before :each do
+    it "ignores modules with unparseable dependencies" do
       response = JSON.parse(http_response)
       release = response['results'][0]['current_release']
       release['metadata']['dependencies'] = [{'name' => 'broken-garbage >= 1.0.0', 'version_requirement' => 'banana'}]
       response['results'] = [release]
-      repository_responds_with(double(:body => JSON.dump(response), :code => '200'))
-    end
 
-    it "ignores modules with unparseable dependencies" do
+      stub_request(:get, /forgeapi.puppet.com/).to_return(status: 200, body: JSON.dump(response))
+
       expect(forge.fetch('puppetlabs/bacula')).to be_empty
     end
   end

data/spec/unit/functions/find_template_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'puppet_spec/files'
+
+describe 'the find_template function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+  include PuppetSpec::Files
+
+  def with_file_content(content)
+    path = tmpfile('find-file-function')
+    file = File.new(path, 'wb')
+    file.sync = true
+    file.print content
+    yield path
+  end
+
+  it 'finds an existing absolute file when given arguments individually' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_template('#{one}', '#{two}'):}")).to have_resource("Notify[#{one}]")
+      end
+    end
+  end
+
+  it 'skips non existing files' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_template('#{one}/nope', '#{two}'):}")).to have_resource("Notify[#{two}]")
+      end
+    end
+  end
+
+  it 'accepts arguments given as an array' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_template(['#{one}', '#{two}']):}")).to have_resource("Notify[#{one}]")
+      end
+    end
+  end
+
+  it 'finds an existing file in a module' do
+    with_file_content('file content') do |name|
+      mod = double('module')
+      allow(mod).to receive(:template).with('myfile').and_return(name)
+      Puppet[:code] = "notify { find_template('mymod/myfile'):}"
+      node = Puppet::Node.new('localhost')
+      compiler = Puppet::Parser::Compiler.new(node)
+      allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
+
+      expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[#{name}]")
+    end
+  end
+
+  it 'returns undef when none of the paths were found' do
+    mod = double('module')
+    allow(mod).to receive(:template).with('myfile').and_return(nil)
+    Puppet[:code] = "notify { String(type(find_template('mymod/myfile', 'nomod/nofile'))):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    # For a module that does not have the file
+    allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
+    # For a module that does not exist
+    allow(compiler.environment).to receive(:module).with('nomod').and_return(nil)
+
+    expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[Undef]")
+  end
+end

data/spec/unit/functions/lookup_spec.rb

@@ -3082,6 +3082,19 @@ describe "The lookup function" do
 
       let(:env_data) { data_files }
 
+      context 'with unencryptable eyaml' do
+        let(:data_files) do
+          {
+            'common.eyaml' => <<-YAML.unindent
+              key_with_invalid_eyaml: ENC[PKCS7,INVALID]
+              YAML
+          }
+        end
+
+        it 'fails and reports error with ENC value, key being looked up and filename' do
+          expect { lookup('key_with_invalid_eyaml') }.to raise_error(Puppet::DataBinding::LookupError, /hiera-eyaml backend error decrypting ENC\[PKCS7,INVALID\] when looking up key_with_invalid_eyaml in .*common\.eyaml\. Error was/)
+        end
+      end
       context 'and a module using eyaml with different options' do
 
         let(:private_module_key) do

data/spec/unit/http/client_spec.rb

@@ -4,7 +4,9 @@ require 'puppet/http'
 
 describe Puppet::HTTP::Client do
   let(:uri) { URI.parse('https://www.example.com') }
-  let(:client) { described_class.new }
+  let(:puppet_context) { Puppet::SSL::SSLContext.new }
+  let(:system_context) { Puppet::SSL::SSLContext.new }
+  let(:client) { described_class.new(ssl_context: puppet_context, system_ssl_context: system_context) }
   let(:credentials) { ['user', 'pass'] }
 
   it 'creates unique sessions' do
@@ -35,7 +37,55 @@ describe Puppet::HTTP::Client do
 
       expect {
         client.connect(uri)
-      }.to raise_error(Puppet::HTTP::ConnectionError, %r{Failed to connect to https://www.example.com:})
+      }.to raise_error(Puppet::HTTP::ConnectionError, %r{^Request to https://www.example.com failed after .* seconds: (Connection refused|No connection could be made because the target machine actively refused it)})
+    end
+
+    it 'raises ConnectionError if the connect times out' do
+      allow_any_instance_of(Net::HTTP).to receive(:start).and_raise(Net::OpenTimeout)
+
+      expect {
+        client.connect(uri)
+      }.to raise_error(Puppet::HTTP::ConnectionError, %r{^Request to https://www.example.com timed out connect operation after .* seconds})
+    end
+
+    it 'connects using the default ssl context' do
+      expect(client.pool).to receive(:with_connection) do |_, verifier|
+        expect(verifier.ssl_context).to equal(puppet_context)
+      end
+
+      client.connect(uri)
+    end
+
+    it 'connects using a specified ssl context' do
+      other_context = Puppet::SSL::SSLContext.new
+
+      expect(client.pool).to receive(:with_connection) do |_, verifier|
+        expect(verifier.ssl_context).to equal(other_context)
+      end
+
+      client.connect(uri, options: {ssl_context: other_context})
+    end
+
+    it 'connects using the system store' do
+      expect(client.pool).to receive(:with_connection) do |_, verifier|
+        expect(verifier.ssl_context).to equal(system_context)
+      end
+
+      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, 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
 
@@ -53,31 +103,32 @@ describe Puppet::HTTP::Client do
     end
 
     it 'raises HTTPError if connection is interrupted while reading' do
-      expect_http_error(EOFError, %r{Request to https://www.example.com interrupted after .* seconds})
+      expect_http_error(EOFError, %r{^Request to https://www.example.com interrupted after .* seconds})
     end
 
     it 'raises HTTPError if connection times out' do
-      expect_http_error(Net::ReadTimeout, %r{Request to https://www.example.com timed out after .* seconds})
+      expect_http_error(Net::ReadTimeout, %r{^Request to https://www.example.com timed out read operation after .* seconds})
     end
 
     it 'raises HTTPError if connection fails' do
-      expect_http_error(ArgumentError, %r{Request to https://www.example.com failed after .* seconds})
+      expect_http_error(ArgumentError, %r{^Request to https://www.example.com failed after .* seconds})
     end
   end
 
   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
 
   context "for GET requests" do
     it "includes default HTTP headers" do
-      stub_request(:get, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+      stub_request(:get, uri).with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        expect(request.headers).to_not include('X-Puppet-Profiling')
+      end
 
       client.get(uri)
     end
@@ -88,6 +139,12 @@ describe Puppet::HTTP::Client do
       client.get(uri, params: {:foo => "bar=baz"})
     end
 
+    it "fails if a user passes in an invalid param type" do
+      environment = Puppet::Node::Environment.create(:testing, [])
+
+      expect{client.get(uri, params: {environment: environment})}.to raise_error(Puppet::HTTP::SerializationError, /HTTP REST queries cannot handle values of type/)
+    end
+
     it "merges custom headers with default ones" do
       stub_request(:get, uri).with(headers: { 'X-Foo' => 'Bar', 'X-Puppet-Version' => /./, 'User-Agent' => /./ })
 
@@ -121,31 +178,113 @@ describe Puppet::HTTP::Client do
 
       expect(io.string).to eq("abc")
     end
+
+    context 'when connecting' do
+      it 'uses a specified ssl context' do
+        stub_request(:get, uri).to_return(body: "abc")
+
+        other_context = Puppet::SSL::SSLContext.new
+
+        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, options: {include_system_store: true})
+      end
+
+      it 'raises an HTTPError if both are specified' do
+        expect {
+          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
+  end
+
+  context "for HEAD requests" do
+    it "includes default HTTP headers" do
+      stub_request(:head, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+
+      client.head(uri)
+    end
+
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:head, uri).with(query: "foo=bar%3Dbaz")
+
+      client.head(uri, params: {:foo => "bar=baz"})
+    end
+
+    it "merges custom headers with default ones" do
+      stub_request(:head, uri).with(headers: { 'X-Foo' => 'Bar', 'X-Puppet-Version' => /./, 'User-Agent' => /./ })
+
+      client.head(uri, headers: {'X-Foo' => 'Bar'})
+    end
+
+    it "returns the response" do
+      stub_request(:head, uri)
+
+      response = client.head(uri)
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "returns the entire response body" do
+      stub_request(:head, uri).to_return(body: "abc")
+
+      expect(client.head(uri).body).to eq("abc")
+    end
+
+    context 'when connecting' do
+      it 'uses a specified ssl context' do
+        stub_request(:head, uri)
+
+        other_context = Puppet::SSL::SSLContext.new
+
+        client.head(uri, options: {ssl_context: other_context})
+      end
+
+      it 'uses the system store' do
+        stub_request(:head, uri)
+
+        client.head(uri, options: {include_system_store: true})
+      end
+
+      it 'raises an HTTPError if both are specified' do
+        expect {
+          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
   end
 
   context "for PUT requests" do
     it "includes default HTTP headers" do
-      stub_request(:put, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+      stub_request(:put, uri).with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        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)
@@ -154,7 +293,180 @@ 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, "", headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: other_context})
+      end
+
+      it 'uses the system store' do
+        stub_request(:put, uri)
+
+        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, "", 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
+  end
+
+  context "for POST requests" do
+    it "includes default HTTP headers" do
+      stub_request(:post, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+
+      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"}, 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'})
+    end
+
+    it "returns the response" do
+      stub_request(:post, uri)
+
+      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)
+    end
+
+    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, "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, "", headers: {'Content-Type' => 'text/plain'}) do |response|
+        response.read_body do |data|
+          io.write(data)
+        end
+      end
+
+      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, "", 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, "", headers: {'Content-Type' => 'text/plain'}, options: {include_system_store: true})
+      end
+
+      it 'raises an HTTPError if both are specified' do
+        expect {
+          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
+  end
+
+  context "for DELETE requests" do
+    it "includes default HTTP headers" do
+      stub_request(:delete, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+
+      client.delete(uri)
+    end
+
+    it "merges custom headers with default ones" do
+      stub_request(:delete, uri).with(headers: { 'X-Foo' => 'Bar', 'X-Puppet-Version' => /./, 'User-Agent' => /./ })
+
+      client.delete(uri, headers: {'X-Foo' => 'Bar'})
+    end
+
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:delete, "https://www.example.com").with(query: "foo=bar%3Dbaz")
+
+      client.delete(uri, params: {:foo => "bar=baz"})
+    end
+
+    it "returns the response" do
+      stub_request(:delete, uri)
+
+      response = client.delete(uri)
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "returns the entire response body" do
+      stub_request(:delete, uri).to_return(body: "abc")
+
+      expect(client.delete(uri).body).to eq("abc")
+    end
+
+    context 'when connecting' do
+      it 'uses a specified ssl context' do
+        stub_request(:delete, uri)
+
+        other_context = Puppet::SSL::SSLContext.new
+
+        client.delete(uri, options: {ssl_context: other_context})
+      end
+
+      it 'uses the system store' do
+        stub_request(:delete, uri)
+
+        client.delete(uri, options: {include_system_store: true})
+      end
+
+      it 'raises an HTTPError if both are specified' do
+        expect {
+          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
   end
 
@@ -162,38 +474,38 @@ 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: {basic_auth: {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: {basic_auth: {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: {basic_auth: {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
     end
 
-    it 'omits basic auth if user is nil' do
+    it 'includes basic auth if user is nil' do
       stub_request(:get, uri).with do |req|
-        expect(req.headers).to_not include('Authorization')
+        expect(req.headers).to include('Authorization')
       end
 
-      client.get(uri, user: nil, password: 'pass')
+      client.get(uri, options: {basic_auth: {user: nil, password: 'pass'}})
     end
 
-    it 'omits basic auth if password is nil' do
+    it 'includes basic auth if password is nil' do
       stub_request(:get, uri).with do |req|
-        expect(req.headers).to_not include('Authorization')
+        expect(req.headers).to include('Authorization')
       end
 
-      client.get(uri, user: 'user', password: nil)
+      client.get(uri, options: {basic_auth: {user: 'user', password: nil}})
     end
   end
 
@@ -219,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
 
@@ -245,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: {basic_auth: {user: 'user', password: 'pass'}})
     end
 
     it "redirects given a relative location" do
@@ -272,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
 
@@ -401,6 +713,32 @@ describe Puppet::HTTP::Client do
       }.to raise_error(Puppet::HTTP::ProtocolError, /Failed to parse Retry-After header 'foo' as an integer or RFC 2822 date/)
     end
 
+    it "should close the connection before sleeping" do
+      retry_after('42')
+
+      site = Puppet::Network::HTTP::Site.from_uri(uri)
+
+      http1 = Net::HTTP.new(site.host, site.port)
+      http1.use_ssl = true
+      allow(http1).to receive(:started?).and_return(true)
+
+      http2 = Net::HTTP.new(site.host, site.port)
+      http2.use_ssl = true
+      allow(http2).to receive(:started?).and_return(true)
+
+
+      pool = Puppet::Network::HTTP::Pool.new(15)
+      client = Puppet::HTTP::Client.new(pool: pool)
+
+      # The "with_connection" method is required to yield started connections
+      allow(pool).to receive(:with_connection).and_yield(http1).and_yield(http2)
+
+      expect(http1).to receive(:finish).ordered
+      expect(::Kernel).to receive(:sleep).with(42).ordered
+
+      client.get(uri)
+    end
+
     it "should sleep and retry if Retry-After is an Integer" do
       retry_after('42')
 
@@ -437,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