puppet 5.3.4 → 6.29.0

data/spec/unit/util/execution_stub_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Util::ExecutionStub do
@@ -16,9 +15,9 @@ describe Puppet::Util::ExecutionStub do
     expect(Puppet::Util::ExecutionStub.current_value).to eq(nil)
   end
 
-  it "should restore normal execution after 'reset' is called" do
+  it "should restore normal execution after 'reset' is called", unless: Puppet::Util::Platform.jruby? do
     # Note: "true" exists at different paths in different OSes
-    if Puppet.features.microsoft_windows?
+    if Puppet::Util::Platform.windows?
       true_command = [Puppet::Util.which('cmd.exe').tr('/', '\\'), '/c', 'exit 0']
     else
       true_command = [Puppet::Util.which('true')]

data/spec/unit/util/feature_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/feature'
@@ -6,49 +5,67 @@ require 'puppet/util/feature'
 describe Puppet::Util::Feature do
   before do
     @features = Puppet::Util::Feature.new("features")
-    @features.stubs(:warn)
+    allow(@features).to receive(:warn)
   end
 
-  it "should be able to add new features" do
-    @features.add(:myfeature) {}
-    expect(@features).to respond_to(:myfeature?)
-  end
-
-  it "should call associated code when loading a feature" do
+  it "should not call associated code when adding a feature" do
     $loaded_feature = false
     @features.add(:myfeature) { $loaded_feature = true}
-    expect($loaded_feature).to be_truthy
+    expect($loaded_feature).to eq(false)
   end
 
   it "should consider a feature absent when the feature load fails" do
     @features.add(:failer) { raise "foo" }
-    expect(@features).not_to be_failer
+    expect(@features.failer?).to eq(false)
   end
 
   it "should consider a feature to be absent when the feature load returns false" do
     @features.add(:failer) { false }
-    expect(@features).not_to be_failer
+    expect(@features.failer?).to eq(false)
+  end
+
+  it "should consider a feature to be absent when the feature load returns nil" do
+    @features.add(:failer) { nil }
+    expect(@features.failer?).to eq(false)
   end
 
   it "should consider a feature to be present when the feature load returns true" do
     @features.add(:available) { true }
-    expect(@features).to be_available
+    expect(@features.available?).to eq(true)
+  end
+
+  it "should consider a feature to be present when the feature load returns truthy" do
+    @features.add(:available) { "yes" }
+    expect(@features.available?).to eq(true)
+  end
+
+  it "should cache the results of a feature load via code block when the block returns true" do
+    $loaded_feature = 0
+    @features.add(:myfeature) { $loaded_feature += 1; true }
+    @features.myfeature?
+    @features.myfeature?
+    expect($loaded_feature).to eq(1)
   end
 
-  it "should cache the results of a feature load via code block" do
+  it "should cache the results of a feature load via code block when the block returns false" do
     $loaded_feature = 0
-    @features.add(:myfeature) { $loaded_feature += 1 }
+    @features.add(:myfeature) { $loaded_feature += 1; false }
     @features.myfeature?
     @features.myfeature?
     expect($loaded_feature).to eq(1)
   end
 
+  it "should not cache the results of a feature load via code block when the block returns nil" do
+    $loaded_feature = 0
+    @features.add(:myfeature) { $loaded_feature += 1; nil }
+    @features.myfeature?
+    @features.myfeature?
+    expect($loaded_feature).to eq(2)
+  end
+
   it "should invalidate the cache for the feature when loading" do
-    # block defined features are evaluated at load time
     @features.add(:myfeature) { false }
     expect(@features).not_to be_myfeature
-    # features with no block have deferred evaluation so an existing cached
-    # value would take precedence
     @features.add(:myfeature)
     expect(@features).to be_myfeature
   end
@@ -59,40 +76,50 @@ describe Puppet::Util::Feature do
 
   it "should consider a feature to be present if all of its libraries are present" do
     @features.add(:myfeature, :libs => %w{foo bar})
-    @features.expects(:require).with("foo")
-    @features.expects(:require).with("bar")
+    expect(@features).to receive(:require).with("foo")
+    expect(@features).to receive(:require).with("bar")
 
     expect(@features).to be_myfeature
   end
 
   it "should log and consider a feature to be absent if any of its libraries are absent" do
     @features.add(:myfeature, :libs => %w{foo bar})
-    @features.expects(:require).with("foo").raises(LoadError)
-    @features.stubs(:require).with("bar")
+    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
+    allow(@features).to receive(:require).with("bar")
 
-    Puppet.expects(:debug)
+    expect(@features).to receive(:debug_once)
 
     expect(@features).not_to be_myfeature
   end
 
   it "should change the feature to be present when its libraries become available" do
     @features.add(:myfeature, :libs => %w{foo bar})
-    @features.expects(:require).twice().with("foo").raises(LoadError).then.returns(nil)
-    @features.stubs(:require).with("bar")
-    Puppet::Util::RubyGems::Source.stubs(:source).returns(Puppet::Util::RubyGems::OldGemsSource)
-    Puppet::Util::RubyGems::OldGemsSource.any_instance.expects(:clear_paths).times(3)
-
-    Puppet.expects(:debug)
+    times_feature_require_called = 0
+    expect(@features).to receive(:require).twice().with("foo") do
+      times_feature_require_called += 1
+      if times_feature_require_called == 1
+        raise LoadError
+      else
+        nil
+      end
+    end
+    allow(@features).to receive(:require).with("bar")
+    allow(Puppet::Util::RubyGems::Source).to receive(:source).and_return(Puppet::Util::RubyGems::Gems18Source)
+    times_clear_paths_called = 0
+    allow_any_instance_of(Puppet::Util::RubyGems::Gems18Source).to receive(:clear_paths) { times_clear_paths_called += 1 }
+
+    expect(@features).to receive(:debug_once)
 
     expect(@features).not_to be_myfeature
     expect(@features).to be_myfeature
+    expect(times_clear_paths_called).to eq(3)
   end
 
   it "should cache load failures when configured to do so" do
     Puppet[:always_retry_plugins] = false
 
     @features.add(:myfeature, :libs => %w{foo bar})
-    @features.expects(:require).with("foo").raises(LoadError)
+    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
 
     expect(@features).not_to be_myfeature
     # second call would cause an expectation exception if 'require' was

data/spec/unit/util/filetype_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/filetype'
@@ -16,15 +15,15 @@ describe Puppet::Util::FileType do
 
     describe "when the file already exists" do
       it "should return the file's contents when asked to read it" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns true
-        Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding.default_external).returns "my text"
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        expect(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding.default_external).and_return("my text")
 
         expect(file.read).to eq("my text")
       end
 
       it "should unlink the file when asked to remove it" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns true
-        Puppet::FileSystem.expects(:unlink).with(path)
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        expect(Puppet::FileSystem).to receive(:unlink).with(path)
 
         file.remove
       end
@@ -32,57 +31,58 @@ describe Puppet::Util::FileType do
 
     describe "when the file does not exist" do
       it "should return an empty string when asked to read the file" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns false
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
 
         expect(file.read).to eq("")
       end
     end
 
     describe "when writing the file" do
-      let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
+      let(:tempfile) { double('tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file") }
+
       before do
-        FileUtils.stubs(:cp)
-        Tempfile.stubs(:new).returns tempfile
+        allow(FileUtils).to receive(:cp)
+        allow(Tempfile).to receive(:new).and_return(tempfile)
       end
 
       it "should first create a temp file and copy its contents over to the file location" do
-        Tempfile.expects(:new).with("puppet", :encoding => Encoding.default_external).returns tempfile
-        tempfile.expects(:print).with("my text")
-        tempfile.expects(:flush)
-        tempfile.expects(:close)
-        FileUtils.expects(:cp).with(tempfile.path, path)
+        expect(Tempfile).to receive(:new).with("puppet", :encoding => Encoding.default_external).and_return(tempfile)
+        expect(tempfile).to receive(:print).with("my text")
+        expect(tempfile).to receive(:flush)
+        expect(tempfile).to receive(:close)
+        expect(FileUtils).to receive(:cp).with(tempfile.path, path)
 
         file.write "my text"
       end
 
       it "should set the selinux default context on the file" do
-        file.expects(:set_selinux_default_context).with(path)
+        expect(file).to receive(:set_selinux_default_context).with(path)
         file.write "eh"
       end
     end
 
     describe "when backing up a file" do
       it "should do nothing if the file does not exist" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns false
-        file.expects(:bucket).never
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+        expect(file).not_to receive(:bucket)
         file.backup
       end
 
       it "should use its filebucket to backup the file if it exists" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
 
-        bucket = mock 'bucket'
-        bucket.expects(:backup).with(path)
+        bucket = double('bucket')
+        expect(bucket).to receive(:backup).with(path)
 
-        file.expects(:bucket).returns bucket
+        expect(file).to receive(:bucket).and_return(bucket)
         file.backup
       end
 
       it "should use the default filebucket" do
-        bucket = mock 'bucket'
-        bucket.expects(:bucket).returns "mybucket"
+        bucket = double('bucket')
+        expect(bucket).to receive(:bucket).and_return("mybucket")
 
-        Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
+        expect(Puppet::Type.type(:filebucket)).to receive(:mkdefaultbucket).and_return(bucket)
 
         expect(file.bucket).to eq("mybucket")
       end
@@ -103,45 +103,57 @@ describe Puppet::Util::FileType do
     # make Puppet::Util::SUIDManager return something deterministic, not the
     # uid of the user running the tests, except where overridden below.
     before :each do
-      Puppet::Util::SUIDManager.stubs(:uid).returns 1234
+      allow(Puppet::Util::SUIDManager).to receive(:uid).and_return(1234)
     end
 
     describe "#read" do
+      before(:each) do
+        allow(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
+      end
+
       it "should run crontab -l as the target user" do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).returns crontab
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(['crontab', '-l'], user_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 
       it "should not switch user if current user is the target user" do
-        Puppet::Util.expects(:uid).with(uid).returns 9000
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], options).returns crontab
+        expect(Puppet::Util).to receive(:uid).with(uid).twice.and_return(9000)
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(['crontab', '-l'], options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 
       it "should treat an absent crontab as empty" do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, absent_crontab)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, absent_crontab)
+        expect(cron.read).to eq('')
+      end
+
+      it "should treat a nonexistent user's crontab as empty" do
+        expect(Puppet::Util).to receive(:uid).with(uid).and_return(nil)
+
         expect(cron.read).to eq('')
       end
 
-      it "should raise an error if the user is not authorized to use cron" do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, unauthorized_crontab)
-        expect {
-          cron.read
-        }.to raise_error Puppet::Error, /User #{uid} not authorized to use cron/
+      it "should return empty if the user is not authorized to use cron" do
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, unauthorized_crontab)
+        expect(cron.read).to eq('')
       end
     end
 
     describe "#remove" do
       it "should run crontab -r as the target user" do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-r'], user_options)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-r'], user_options)
         cron.remove
       end
 
       it "should not switch user if current user is the target user" do
-        Puppet::Util.expects(:uid).with(uid).returns 9000
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        Puppet::Util::Execution.expects(:execute).with(['crontab','-r'], options)
+        expect(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab','-r'], options)
         cron.remove
       end
     end
@@ -150,8 +162,8 @@ describe Puppet::Util::FileType do
       before :each do
         @tmp_cron = Tempfile.new("puppet_crontab_spec")
         @tmp_cron_path = @tmp_cron.path
-        Puppet::Util.stubs(:uid).with(uid).returns 9000
-        Tempfile.expects(:new).with("puppet_#{name}", :encoding => Encoding.default_external).returns @tmp_cron
+        allow(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
+        expect(Tempfile).to receive(:new).with("puppet_#{name}", :encoding => Encoding.default_external).and_return(@tmp_cron)
       end
 
       after :each do
@@ -159,25 +171,25 @@ describe Puppet::Util::FileType do
       end
 
       it "should run crontab as the target user on a temporary file" do
-        File.expects(:chown).with(9000, nil, @tmp_cron_path)
-        Puppet::Util::Execution.expects(:execute).with(["crontab", @tmp_cron_path], user_options)
+        expect(File).to receive(:chown).with(9000, nil, @tmp_cron_path)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["crontab", @tmp_cron_path], user_options)
 
-        @tmp_cron.expects(:print).with("foo\n")
+        expect(@tmp_cron).to receive(:print).with("foo\n")
         cron.write "foo\n"
       end
 
       it "should not switch user if current user is the target user" do
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        File.expects(:chown).with(9000, nil, @tmp_cron_path)
-        Puppet::Util::Execution.expects(:execute).with(["crontab", @tmp_cron_path], options)
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
+        expect(File).to receive(:chown).with(9000, nil, @tmp_cron_path)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["crontab", @tmp_cron_path], options)
 
-        @tmp_cron.expects(:print).with("foo\n")
+        expect(@tmp_cron).to receive(:print).with("foo\n")
         cron.write "foo\n"
       end
     end
   end
 
-  describe "the suntab filetype", :unless => Puppet.features.microsoft_windows? do
+  describe "the suntab filetype", :unless => Puppet::Util::Platform.windows? do
     let(:type)           { Puppet::Util::FileType.filetype(:suntab) }
     let(:name)           { type.name }
     let(:crontab_output) { 'suntab_output' }
@@ -194,7 +206,7 @@ describe Puppet::Util::FileType do
     it_should_behave_like "crontab provider"
   end
 
-  describe "the aixtab filetype", :unless => Puppet.features.microsoft_windows? do
+  describe "the aixtab filetype", :unless => Puppet::Util::Platform.windows? do
     let(:type)           { Puppet::Util::FileType.filetype(:aixtab) }
     let(:name)           { type.name }
     let(:crontab_output) { 'aixtab_output' }

data/spec/unit/util/http_proxy_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 require 'puppet/util/http_proxy'
 
 describe Puppet::Util::HttpProxy do
+  include Puppet::Network::HTTP::Compression.module
+
   before(:all) do
     ENV['http_proxy'] = nil
     ENV['HTTP_PROXY'] = nil
@@ -10,6 +12,114 @@ describe Puppet::Util::HttpProxy do
 
   host, port, user, password = 'some.host', 1234, 'user1', 'pAssw0rd'
 
+  def expects_direct_connection_to(http, www)
+    expect(http.address).to eq(www.host)
+    expect(http.port).to eq(www.port)
+
+    expect(http.proxy_address).to be_nil
+    expect(http.proxy_port).to be_nil
+    expect(http.proxy_user).to be_nil
+    expect(http.proxy_pass).to be_nil
+  end
+
+  def expects_proxy_connection_via(http, www, host, port, user, password)
+    expect(http.address).to eq(www.host)
+    expect(http.port).to eq(www.port)
+
+    expect(http.proxy_address).to eq(host)
+    expect(http.proxy_port).to eq(port)
+    expect(http.proxy_user).to eq(user)
+    expect(http.proxy_pass).to eq(password)
+  end
+
+  describe '.proxy' do
+    let(:www) { URI::HTTP.build(host: 'www.example.com', port: 80) }
+
+    it 'uses a proxy' do
+      Puppet[:http_proxy_host] = host
+      Puppet[:http_proxy_port] = port
+      Puppet[:http_proxy_user] = user
+      Puppet[:http_proxy_password] = password
+
+      http = subject.proxy(www)
+      expects_proxy_connection_via(http, www, host, port, user, password)
+    end
+
+    it 'connects directly to the server' do
+      http = subject.proxy(www)
+      expects_direct_connection_to(http, www)
+    end
+
+    it 'connects directly to the server when HTTP_PROXY environment variable is set, but server matches no_proxy setting' do
+      Puppet[:http_proxy_host] = host
+      Puppet[:http_proxy_port] = port
+      Puppet[:no_proxy] = www.host
+
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+    end
+
+    context 'when setting no_proxy' do
+      before :each do
+        Puppet[:http_proxy_host] = host
+        Puppet[:http_proxy_port] = port
+      end
+
+      it 'connects directly to the server when HTTP_PROXY environment variable is set, but server matches no_proxy setting' do
+        Puppet[:no_proxy] = www.host
+
+        Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
+          http = subject.proxy(www)
+          expects_direct_connection_to(http, www)
+        end
+      end
+
+      it 'connects directly to the server when no_proxy matches wildcard domain' do
+        Puppet[:no_proxy] = '*.example.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when no_proxy matches dotted domain' do
+        Puppet[:no_proxy] = '.example.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when no_proxy matches a domain suffix like ruby does' do
+        Puppet[:no_proxy] = 'example.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when no_proxy matches a partial suffix like ruby does' do
+        Puppet[:no_proxy] = 'ample.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when it is a subdomain of no_proxy' do
+        Puppet[:no_proxy] = '*.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when no_proxy is *' do
+        Puppet[:no_proxy] = '*'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+    end
+  end
+
   describe ".http_proxy_env" do
     it "should return nil if no environment variables" do
       expect(subject.http_proxy_env).to eq(nil)
@@ -127,9 +237,32 @@ describe Puppet::Util::HttpProxy do
 
   end
 
+  describe ".no_proxy" do
+    no_proxy = '127.0.0.1, localhost'
+    it "should use a no_proxy list if set in environment" do
+      Puppet::Util.withenv('NO_PROXY' => no_proxy) do
+        expect(subject.no_proxy).to eq(no_proxy)
+      end
+    end
+
+    it "should use a no_proxy list if set in config" do
+      Puppet.settings[:no_proxy] = no_proxy
+      expect(subject.no_proxy).to eq(no_proxy)
+    end
+
+    it "should use environment variable before puppet settings" do
+      no_proxy_puppet_setting = '10.0.0.1, localhost'
+      Puppet::Util.withenv('NO_PROXY' => no_proxy) do
+        Puppet.settings[:no_proxy] = no_proxy_puppet_setting
+        expect(subject.no_proxy).to eq(no_proxy)
+      end
+    end
+  end
+
   describe ".no_proxy?" do
     no_proxy = '127.0.0.1, localhost, mydomain.com, *.otherdomain.com, oddport.com:8080, *.otheroddport.com:8080, .anotherdomain.com, .anotheroddport.com:8080'
-    it "should return false if no_proxy does not exist in env" do
+
+    it "should return false if no_proxy does not exist in environment or puppet settings" do
       Puppet::Util.withenv('no_proxy' => nil) do
         dest = 'https://puppetlabs.com'
         expect(subject.no_proxy?(dest)).to be false
@@ -216,28 +349,45 @@ describe Puppet::Util::HttpProxy do
 
   describe '.request_with_redirects' do
     let(:dest) { URI.parse('http://mydomain.com/some/path') }
-    let(:http_ok) { stub('http ok', :code => 200, :message => 'HTTP OK') }
 
     it 'generates accept and accept-encoding headers' do
-      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
-      Net::HTTP.any_instance.expects(:get).with do |_, headers|
-        expect(headers)
-          .to match({'Accept' => '*/*',
-                     'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-                     'User-Agent' => /Puppet/})
-      end.returns(http_ok)
+      stub_request(:head, dest)
+
+      headers = {
+        'Accept' => '*/*',
+        'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+        'User-Agent' => /Puppet/
+      }
+      stub_request(:get, dest).with(headers: headers)
 
       subject.request_with_redirects(dest, :get, 0)
     end
 
+    it 'can return a compressed response body' do
+      stub_request(:head, dest)
+
+      compressed_body = [
+        0x1f, 0x8b, 0x08, 0x08, 0xe9, 0x08, 0x7a, 0x5a, 0x00, 0x03,
+        0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0xcb, 0xc8, 0xe4, 0x02,
+        0x00, 0x7a, 0x7a, 0x6f, 0xed, 0x03, 0x00, 0x00, 0x00
+      ].pack('C*')
+
+      stub_request(:get, dest).to_return(status: 200, body: compressed_body, headers: { 'Content-Encoding' => 'gzip' })
+
+      expect(
+        uncompress_body(subject.request_with_redirects(dest, :get, 0))
+      ).to eq("hi\n")
+    end
+
     it 'generates accept and accept-encoding headers when a block is provided' do
-      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
-      Net::HTTP.any_instance.expects(:request_get).with do |_, headers, &block|
-        expect(headers)
-          .to match({'Accept' => '*/*',
-                     'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-                     'User-Agent' => /Puppet/})
-      end.returns(http_ok)
+      stub_request(:head, dest)
+
+      headers = {
+        'Accept' => '*/*',
+        'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+        'User-Agent' => /Puppet/
+      }
+      stub_request(:get, dest).with(headers: headers)
 
       subject.request_with_redirects(dest, :get, 0) do
         # unused
@@ -245,9 +395,20 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'only makes a single HEAD request' do
-      Net::HTTP.any_instance.expects(:head).with(anything, anything).returns(http_ok)
+      stub_request(:head, dest)
 
       subject.request_with_redirects(dest, :head, 0)
     end
+
+    it 'preserves query parameters' do
+      url = URI.parse('http://mydomain.com/some/path?foo=bar')
+
+      stub_request(:head, url)
+      stub_request(:get, url)
+
+      subject.request_with_redirects(url, :get, 0) do
+        # unused
+      end
+    end
   end
 end