puppet 6.16.0-universal-darwin → 6.20.0-universal-darwin

data/spec/unit/indirector/request_spec.rb

@@ -94,7 +94,7 @@ describe Puppet::Indirector::Request do
 
       describe "and the URI is a 'file' URI" do
         before do
-          @request = Puppet::Indirector::Request.new(:ind, :method, "#{URI.unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
+          @request = Puppet::Indirector::Request.new(:ind, :method, "#{Puppet::Util.uri_unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
         end
 
         it "should set the request key to the unescaped full file path" do
@@ -126,8 +126,8 @@ describe Puppet::Indirector::Request do
         expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/", nil).port).to eq(543)
       end
 
-      it "should default to the masterport if the URI scheme is 'puppet'" do
-        Puppet[:masterport] = "321"
+      it "should default to the serverport if the URI scheme is 'puppet'" do
+        Puppet[:serverport] = "321"
         expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/", nil).port).to eq(321)
       end
 
@@ -534,7 +534,7 @@ describe Puppet::Indirector::Request do
           expect(request.server).to be_nil
           expect(request.port).to be_nil
           expect(Puppet.settings[:server]).not_to be_nil
-          expect(Puppet.settings[:masterport]).not_to be_nil
+          expect(Puppet.settings[:serverport]).not_to be_nil
         end
       end
     end
@@ -552,7 +552,7 @@ describe Puppet::Indirector::Request do
       req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
       req.do_request() do |request|
         expect(request.server).to eq(Puppet.settings[:server])
-        expect(request.port).to eq(Puppet.settings[:masterport])
+        expect(request.port).to eq(Puppet.settings[:serverport])
       end
     end
   end

data/spec/unit/indirector/rest_spec.rb

@@ -249,7 +249,7 @@ describe Puppet::Indirector::REST do
 
   it "should default to :port for the port setting" do
     expect(terminus_class).to receive(:port_setting).and_return(nil)
-    Puppet[:masterport] = "543"
+    Puppet[:serverport] = "543"
     expect(terminus_class.port).to eq(543)
   end
 

data/spec/unit/indirector/status/rest_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::Indirector::Status::Rest do
 
   before :each do
     Puppet[:server] = 'compiler.example.com'
-    Puppet[:masterport] = 8140
+    Puppet[:serverport] = 8140
 
     described_class.indirection.terminus_class = :rest
   end

data/spec/unit/indirector/yaml_spec.rb

@@ -38,30 +38,30 @@ describe Puppet::Indirector::Yaml do
 
   before :each do
     Puppet[:clientyamldir] = dir
-    allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    allow(Puppet.run_mode).to receive(:server?).and_return(false)
   end
 
   describe "when choosing file location" do
-    it "should use the server_datadir if the run_mode is master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+    it "should use the server_datadir if the run_mode is server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me)).to match(/^#{serverdir}/)
     end
 
-    it "should use the client yamldir if the run_mode is not master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    it "should use the client yamldir if the run_mode is not server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(false)
       Puppet[:clientyamldir] = clientdir
       expect(terminus.path(:me)).to match(/^#{clientdir}/)
     end
 
     it "should use the extension if one is specified" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me,'.farfignewton')).to match(%r{\.farfignewton$})
     end
 
     it "should assume an extension of .yaml if none is specified" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me)).to match(%r{\.yaml$})
     end

data/spec/unit/indirector_spec.rb

@@ -112,8 +112,8 @@ describe Puppet::Indirector, "when registering an indirection" do
   end
 
   it "should pass any provided options to the indirection during initialization" do
-    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:some => :options, :indirected_class => 'Thingie'})
-    @indirection = @thingie.indirects :first, :some => :options
+    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:doc => 'some docs', :indirected_class => 'Thingie'})
+    @indirection = @thingie.indirects :first, :doc => 'some docs'
   end
 
   it "should extend the class to handle serialization" do

data/spec/unit/interface_spec.rb

@@ -180,7 +180,7 @@ describe Puppet::Interface do
           display_global_options "modulepath"
         end
       end
-      face.display_global_options =~ ["environment"]
+      expect(face.display_global_options).to match(["environment"])
     end
 
     it "should not fail when a face d_g_o duplicates an action d_g_o" do
@@ -200,8 +200,8 @@ describe Puppet::Interface do
         action :foo do when_invoked {|_| true} ; display_global_options "environment" end
         action :bar do when_invoked {|_| true} ; display_global_options "environment" end
       end
-      face.get_action(:foo).display_global_options =~ ["environment"]
-      face.get_action(:bar).display_global_options =~ ["environment"]
+      expect(face.get_action(:foo).display_global_options).to match(["environment"])
+      expect(face.get_action(:bar).display_global_options).to match(["environment"])
     end
       
   end

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -247,6 +247,21 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
           expect(subject).to include :result => :success
           graph_should_include 'pmtacceptance-mysql', nil => v('0.8.0')
         end
+
+        context 'with an already installed dependency' do
+          before { preinstall('pmtacceptance-stdlib', '2.6.0') }
+
+          def options
+            super.merge(:version => '0.7.0')
+          end
+
+          it 'installs given version without errors and does not change version of dependency' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-mysql', nil => v('0.7.0')
+            expect(subject[:error]).to be_nil
+            graph_should_include 'pmtacceptance-stdlib', v('2.6.0') => v('2.6.0')
+          end
+        end
       end
 
       context 'with a --version that cannot satisfy' do
@@ -258,6 +273,20 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
           expect(subject).to include :result => :failure
         end
 
+        it 'prints a detailed error containing the modules that would not be satisfied' do
+          graph = double(SemanticPuppet::Dependency::Graph, :modules => ['pmtacceptance-mysql'])
+          exception = SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph)
+          allow(exception).to receive(:respond_to?).and_return(true)
+          allow(exception).to receive(:unsatisfied).and_return('pmtacceptance-mysql')
+          allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(exception)
+
+          expect(subject[:error]).to include(:multiline)
+          expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+          expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+          expect(subject[:error][:multiline]).to include("pmtacceptance-keystone, expects 'pmtacceptance-mysql': >=0.6.1 <1.0.0")
+          expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+        end
+
         context 'with --ignore-dependencies' do
           def options
             super.merge(:ignore_dependencies => true)
@@ -278,6 +307,43 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
             graph_should_include 'pmtacceptance-mysql', nil => v('2.1.0')
           end
         end
+
+        context 'with an already installed dependency' do
+          let(:graph) {
+            double(SemanticPuppet::Dependency::Graph,
+              :dependencies => {
+                'pmtacceptance-mysql' => {
+                  :version => '2.1.0'
+                }
+              },
+              :modules => ['pmtacceptance-mysql'],
+              :unsatisfied => 'pmtacceptance-stdlib'
+            )
+          }
+
+          let(:unsatisfiable_graph_exception) { SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph) }
+
+          before do
+            allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(unsatisfiable_graph_exception)
+            allow(unsatisfiable_graph_exception).to receive(:respond_to?).and_return(true)
+            allow(unsatisfiable_graph_exception).to receive(:unsatisfied).and_return(graph.unsatisfied)
+
+            preinstall('pmtacceptance-stdlib', '2.6.0')
+          end
+
+          def options
+            super.merge(:version => '2.1.0')
+          end
+
+          it 'fails to install and outputs a multiline error containing the versions, expectations and workaround' do
+            expect(subject).to include :result => :failure
+            expect(subject[:error]).to include(:multiline)
+            expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (v2.1.0)")
+            expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+            expect(subject[:error][:multiline]).to include("pmtacceptance-stdlib, installed: 2.6.0, expected: >= 2.2.1")
+            expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+          end
+        end
       end
     end
 

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

@@ -86,4 +86,24 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
         and_yield(type, name, {:entry => entry})
     entry
   end
+
+  describe "Extracts tars with long and short pathnames" do
+    let (:sourcetar) { fixtures('module.tar.gz') }
+    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
+    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
+
+    it "unpacks a tar with a short path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
+    end
+
+    it "unpacks a tar with a long path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
+    end
+  end
 end

data/spec/unit/network/authconfig_spec.rb

@@ -6,9 +6,6 @@ describe Puppet::Network::DefaultAuthProvider do
   before :each do
     allow(Puppet::FileSystem).to receive(:stat).and_return(double('stat', :ctime => :now))
     allow(Time).to receive(:now).and_return(Time.now)
-
-    allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:exists?).and_return(true)
-    # FIXME @authprovider = Puppet::Network::DefaultAuthProvider.new("dummy")
   end
 
   describe "when initializing" do

data/spec/unit/network/format_support_spec.rb

@@ -67,8 +67,9 @@ describe Puppet::Network::FormatHandler do
       end
 
       it "should log a debug message" do
-        expect(Puppet).to receive(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
-        expect(Puppet).to receive(:debug).with("FormatTester supports formats: two one")
+        Puppet[:log_level] = 'debug'
+        expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)") }
+        expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("FormatTester supports formats: two one") }
         FormatTester.supported_formats
       end
     end

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

@@ -17,7 +17,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
-    allow(handler).to receive(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
@@ -25,10 +24,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:env_loaders) { Puppet::Environments::Static.new(environment) }
     let(:params) { { :environment => "env" } }
 
-    before do
-      allow(handler).to receive(:handler).and_return("foo")
-    end
-
     around do |example|
       Puppet.override(:environments => env_loaders) do
         example.run
@@ -180,10 +175,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
     let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
-    before do
-      allow(handler).to receive(:handler).and_return("foo")
-    end
-
     it "should include the environment in the query string of the URI" do
       expect(handler.class.request_to_uri(request)).to eq("#{master_url_prefix}/foo/with%20spaces?environment=myenv&foo=bar")
     end
@@ -344,7 +335,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/api/master/v3/environments_spec.rb

@@ -7,13 +7,14 @@ require 'matchers/json'
 describe Puppet::Network::HTTP::API::Master::V3::Environments do
   include JSONMatchers
 
-  it "responds with all of the available environments" do
-    environment = Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests')
-    loader = Puppet::Environments::Static.new(environment)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+  let(:environment) { Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests') }
+  let(:loader) { Puppet::Environments::Static.new(environment) }
+  let(:handler) { Puppet::Network::HTTP::API::Master::V3::Environments.new(loader) }
+  let(:request) { Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }) }
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+  it "responds with all of the available environments" do
+    handler.call(request, response)
 
     expect(response.code).to eq(200)
     expect(response.type).to eq("application/json")
@@ -33,29 +34,17 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for unlimited timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(Float::INFINITY)
-    environment = Puppet::Node::Environment.create(:production, [])
-    env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+    Puppet[:environment_timeout] = 'unlimited'
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
 
   it "the response conforms to the environments schema for integer timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(1)
-    environment = Puppet::Node::Environment.create(:production, [])
-    env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
-
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    Puppet[:environment_timeout] = 1
+
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end

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

@@ -8,6 +8,8 @@ describe Puppet::Network::HTTP::Connection do
   let(:port) { 8140 }
   let(:path) { '/foo' }
   let(:url) { "https://#{host}:#{port}#{path}" }
+  let(:params) { { 'key' => 'a value' } }
+  let(:encoded_url_with_params) { "#{url}?%7B%22key%22:%22a%20value%22%7D" }
 
   shared_examples_for "an HTTP connection" do |klass, legacy_api|
     subject { klass.new(host, port, :verify => Puppet::SSL::Validator.no_validator) }
@@ -81,9 +83,9 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "stringifies keys and encodes values in the query" do
-        stub_request(:get, url).with(query: "foo=bar%3Dbaz")
+        stub_request(:get, encoded_url_with_params)
 
-        subject.request_get("#{path}?foo=bar=baz") { |_| }
+        subject.request_get("#{path}?#{params.to_json}") { |_| }
       end
 
       it "merges custom headers with default ones" do
@@ -101,9 +103,10 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a URL string as the path" do
-        stub_request(:get, url)
+        url_with_query = "#{url}?foo=bar"
+        stub_request(:get, url_with_query)
 
-        response = subject.request_get(url) { |_| }
+        response = subject.request_get(url_with_query) { |_| }
         expect(response).to be_an_instance_of(Net::HTTPOK)
       end
     end
@@ -118,9 +121,9 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "stringifies keys and encodes values in the query" do
-        stub_request(:head, url).with(query: "foo=bar%3Dbaz")
+        stub_request(:head, encoded_url_with_params)
 
-        subject.request_head("#{path}?foo=bar=baz") { |_| }
+        subject.request_head("#{path}?#{params.to_json}") { |_| }
       end
 
       it "merges custom headers with default ones" do
@@ -138,9 +141,10 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a URL string as the path" do
-        stub_request(:head, url)
+        url_with_query = "#{url}?foo=bar"
+        stub_request(:head, url_with_query)
 
-        response = subject.request_head(url) { |_| }
+        response = subject.request_head(url_with_query) { |_| }
         expect(response).to be_an_instance_of(Net::HTTPOK)
       end
     end
@@ -155,9 +159,9 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "stringifies keys and encodes values in the query" do
-        stub_request(:post, url).with(query: "foo=bar%3Dbaz")
+        stub_request(:post, encoded_url_with_params)
 
-        subject.request_post("#{path}?foo=bar=baz", "") { |_| }
+        subject.request_post("#{path}?#{params.to_json}", "") { |_| }
       end
 
       it "merges custom headers with default ones" do
@@ -175,9 +179,10 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a URL string as the path" do
-        stub_request(:post, url)
+        url_with_query = "#{url}?foo=bar"
+        stub_request(:post, url_with_query)
 
-        response = subject.request_post(url, "") { |_| }
+        response = subject.request_post(url_with_query, "") { |_| }
         expect(response).to be_an_instance_of(Net::HTTPOK)
       end
     end
@@ -190,9 +195,9 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "stringifies keys and encodes values in the query" do
-        stub_request(:get, url).with(query: "foo=bar%3Dbaz")
+        stub_request(:get, encoded_url_with_params)
 
-        subject.get("#{path}?foo=bar=baz")
+        subject.get("#{path}?#{params.to_json}")
       end
 
       it "merges custom headers with default ones" do
@@ -217,9 +222,10 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a URL string as the path" do
-        stub_request(:get, url)
+        url_with_query = "#{url}?foo=bar"
+        stub_request(:get, url_with_query)
 
-        response = subject.get(url)
+        response = subject.get(url_with_query)
         expect(response).to be_an_instance_of(Net::HTTPOK)
       end
     end
@@ -232,9 +238,9 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "stringifies keys and encodes values in the query" do
-        stub_request(:head, url).with(query: "foo=bar%3Dbaz")
+        stub_request(:head, encoded_url_with_params)
 
-        subject.head("#{path}?foo=bar=baz")
+        subject.head("#{path}?#{params.to_json}")
       end
 
       it "merges custom headers with default ones" do
@@ -252,9 +258,10 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a URL string as the path" do
-        stub_request(:head, url)
+        url_with_query = "#{url}?foo=bar"
+        stub_request(:head, url_with_query)
 
-        response = subject.head(url)
+        response = subject.head(url_with_query)
         expect(response).to be_an_instance_of(Net::HTTPOK)
       end
     end
@@ -267,9 +274,9 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "stringifies keys and encodes values in the query" do
-        stub_request(:put, url).with(query: "foo=bar%3Dbaz")
+        stub_request(:put, encoded_url_with_params)
 
-        subject.put("#{path}?foo=bar=baz", "")
+        subject.put("#{path}?#{params.to_json}", "")
       end
 
       it "includes custom headers" do
@@ -307,9 +314,10 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a URL string as the path" do
-        stub_request(:put, url)
+        url_with_query = "#{url}?foo=bar"
+        stub_request(:put, url_with_query)
 
-        response = subject.put(url, '')
+        response = subject.put(url_with_query, '')
         expect(response).to be_an_instance_of(Net::HTTPOK)
       end
     end
@@ -322,9 +330,9 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "stringifies keys and encodes values in the query" do
-        stub_request(:post, url).with(query: "foo=bar%3Dbaz")
+        stub_request(:post, encoded_url_with_params)
 
-        subject.post("#{path}?foo=bar=baz", "", {'Content-Type' => 'text/plain'})
+        subject.post("#{path}?#{params.to_json}", "", {'Content-Type' => 'text/plain'})
       end
 
       it "includes custom headers" do
@@ -362,9 +370,10 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a URL string as the path" do
-        stub_request(:post, url)
+        url_with_query = "#{url}?foo=bar"
+        stub_request(:post, url_with_query)
 
-        response = subject.post(url, '')
+        response = subject.post(url_with_query, '')
         expect(response).to be_an_instance_of(Net::HTTPOK)
       end
     end
@@ -383,9 +392,9 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "stringifies keys and encodes values in the query" do
-        stub_request(:delete, url).with(query: "foo=bar%3Dbaz")
+        stub_request(:delete, encoded_url_with_params)
 
-        subject.delete("#{path}?foo=bar=baz")
+        subject.delete("#{path}?#{params.to_json}")
       end
 
       it "returns the response" do
@@ -403,9 +412,10 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a URL string as the path" do
-        stub_request(:delete, url)
+        url_with_query = "#{url}?foo=bar"
+        stub_request(:delete, url_with_query)
 
-        response = subject.delete(url)
+        response = subject.delete(url_with_query)
         expect(response).to be_an_instance_of(Net::HTTPOK)
       end
     end