puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

data/spec/unit/util/execution_stub_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Util::ExecutionStub do
@@ -15,9 +16,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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/feature'
@@ -5,49 +6,67 @@ require 'puppet/util/feature'
 describe Puppet::Util::Feature do
   before do
     @features = Puppet::Util::Feature.new("features")
-    allow(@features).to receive(:warn)
+    @features.stubs(: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 cache the results of a feature load via code block" do
+  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 }
+    @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 when the block returns false" do
+    $loaded_feature = 0
+    @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
@@ -58,31 +77,30 @@ 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})
-    expect(@features).to receive(:require).with("foo")
-    expect(@features).to receive(:require).with("bar")
+    @features.expects(:require).with("foo")
+    @features.expects(: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})
-    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
-    allow(@features).to receive(:require).with("bar")
+    @features.expects(:require).with("foo").raises(LoadError)
+    @features.stubs(:require).with("bar")
 
-    expect(Puppet).to receive(:debug)
+    Puppet.expects(:debug)
 
     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})
-    expect(@features).to receive(:require).ordered.with("foo").and_raise(LoadError)
-    expect(@features).to receive(:require).ordered.with("foo").and_return(nil)
-    allow(@features).to receive(:require).with("bar")
-    allow(Puppet::Util::RubyGems::Source).to receive(:source).and_return(Puppet::Util::RubyGems::OldGemsSource)
-    expect_any_instance_of(Puppet::Util::RubyGems::OldGemsSource).to receive(:clear_paths).exactly(3).times
+    @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::Gems18Source)
+    Puppet::Util::RubyGems::Gems18Source.any_instance.expects(:clear_paths).times(3)
 
-    expect(Puppet).to receive(:debug)
+    Puppet.expects(:debug)
 
     expect(@features).not_to be_myfeature
     expect(@features).to be_myfeature
@@ -92,7 +110,7 @@ describe Puppet::Util::Feature do
     Puppet[:always_retry_plugins] = false
 
     @features.add(:myfeature, :libs => %w{foo bar})
-    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
+    @features.expects(:require).with("foo").raises(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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/filetype'
@@ -15,15 +16,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
-        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")
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding.default_external).returns "my text"
 
         expect(file.read).to eq("my text")
       end
 
       it "should unlink the file when asked to remove it" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect(Puppet::FileSystem).to receive(:unlink).with(path)
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        Puppet::FileSystem.expects(:unlink).with(path)
 
         file.remove
       end
@@ -31,58 +32,57 @@ 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
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+        Puppet::FileSystem.expects(:exist?).with(path).returns false
 
         expect(file.read).to eq("")
       end
     end
 
     describe "when writing the file" do
-      let(:tempfile) { double('tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file") }
-
+      let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
       before do
-        allow(FileUtils).to receive(:cp)
-        allow(Tempfile).to receive(:new).and_return(tempfile)
+        FileUtils.stubs(:cp)
+        Tempfile.stubs(:new).returns tempfile
       end
 
       it "should first create a temp file and copy its contents over to the file location" do
-        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)
+        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)
 
         file.write "my text"
       end
 
       it "should set the selinux default context on the file" do
-        expect(file).to receive(:set_selinux_default_context).with(path)
+        file.expects(: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
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
-        expect(file).not_to receive(:bucket)
+        Puppet::FileSystem.expects(:exist?).with(path).returns false
+        file.expects(:bucket).never
         file.backup
       end
 
       it "should use its filebucket to backup the file if it exists" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
 
-        bucket = double('bucket')
-        expect(bucket).to receive(:backup).with(path)
+        bucket = mock 'bucket'
+        bucket.expects(:backup).with(path)
 
-        expect(file).to receive(:bucket).and_return(bucket)
+        file.expects(:bucket).returns bucket
         file.backup
       end
 
       it "should use the default filebucket" do
-        bucket = double('bucket')
-        expect(bucket).to receive(:bucket).and_return("mybucket")
+        bucket = mock 'bucket'
+        bucket.expects(:bucket).returns "mybucket"
 
-        expect(Puppet::Type.type(:filebucket)).to receive(:mkdefaultbucket).and_return(bucket)
+        Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
 
         expect(file.bucket).to eq("mybucket")
       end
@@ -103,57 +103,49 @@ 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
-      allow(Puppet::Util::SUIDManager).to receive(:uid).and_return(1234)
+      Puppet::Util::SUIDManager.stubs(:uid).returns 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
-        expect(Puppet::Util::Execution).to receive(:execute)
+        Puppet::Util::Execution.expects(:execute)
           .with(['crontab', '-l'], user_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
+          .returns(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
-        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))
+        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(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 
       it "should treat an absent crontab as empty" do
-        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)
-
+        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, absent_crontab)
         expect(cron.read).to eq('')
       end
 
-      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('')
+      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/
       end
     end
 
     describe "#remove" do
       it "should run crontab -r as the target user" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-r'], user_options)
+        Puppet::Util::Execution.expects(:execute).with(['crontab', '-r'], user_options)
         cron.remove
       end
 
       it "should not switch user if current user is the target user" do
-        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)
+        Puppet::Util.expects(:uid).with(uid).returns 9000
+        Puppet::Util::SUIDManager.expects(:uid).returns 9000
+        Puppet::Util::Execution.expects(:execute).with(['crontab','-r'], options)
         cron.remove
       end
     end
@@ -162,8 +154,8 @@ describe Puppet::Util::FileType do
       before :each do
         @tmp_cron = Tempfile.new("puppet_crontab_spec")
         @tmp_cron_path = @tmp_cron.path
-        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)
+        Puppet::Util.stubs(:uid).with(uid).returns 9000
+        Tempfile.expects(:new).with("puppet_#{name}", :encoding => Encoding.default_external).returns @tmp_cron
       end
 
       after :each do
@@ -171,25 +163,25 @@ describe Puppet::Util::FileType do
       end
 
       it "should run crontab as the target user on a temporary file" do
-        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)
+        File.expects(:chown).with(9000, nil, @tmp_cron_path)
+        Puppet::Util::Execution.expects(:execute).with(["crontab", @tmp_cron_path], user_options)
 
-        expect(@tmp_cron).to receive(:print).with("foo\n")
+        @tmp_cron.expects(:print).with("foo\n")
         cron.write "foo\n"
       end
 
       it "should not switch user if current user is the target user" do
-        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)
+        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(@tmp_cron).to receive(:print).with("foo\n")
+        @tmp_cron.expects(: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' }
@@ -206,7 +198,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

@@ -12,103 +12,6 @@ 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
-
-    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)
@@ -226,32 +129,9 @@ 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 environment or puppet settings" do
+    it "should return false if no_proxy does not exist in env" do
       Puppet::Util.withenv('no_proxy' => nil) do
         dest = 'https://puppetlabs.com'
         expect(subject.no_proxy?(dest)).to be false
@@ -338,22 +218,22 @@ describe Puppet::Util::HttpProxy do
 
   describe '.request_with_redirects' do
     let(:dest) { URI.parse('http://mydomain.com/some/path') }
-    let(:http_ok) { double('http ok', :code => 200, :message => 'HTTP OK') }
+    let(:http_ok) { stub('http ok', :code => 200, :message => 'HTTP OK') }
 
     it 'generates accept and accept-encoding headers' do
-      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
-      expect_any_instance_of(Net::HTTP).to receive(:get) do |_, _, headers|
+      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.and_return(http_ok)
+      end.returns(http_ok)
 
       subject.request_with_redirects(dest, :get, 0)
     end
 
     it 'can return a compressed response body' do
-      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
+      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
 
       compressed_body = [
         0x1f, 0x8b, 0x08, 0x08, 0xe9, 0x08, 0x7a, 0x5a, 0x00, 0x03,
@@ -361,9 +241,9 @@ describe Puppet::Util::HttpProxy do
         0x00, 0x7a, 0x7a, 0x6f, 0xed, 0x03, 0x00, 0x00, 0x00
       ].pack('C*')
 
-      response = double('http ok', :code => 200, :message => 'HTTP OK', :body => compressed_body)
-      allow(response).to receive(:[]).with('content-encoding').and_return('gzip')
-      expect_any_instance_of(Net::HTTP).to receive(:get).and_return(response)
+      response = stub('http ok', :code => 200, :message => 'HTTP OK', :body => compressed_body)
+      response.stubs(:[]).with('content-encoding').returns('gzip')
+      Net::HTTP.any_instance.expects(:get).returns(response)
 
       expect(
         uncompress_body(subject.request_with_redirects(dest, :get, 0))
@@ -371,13 +251,13 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'generates accept and accept-encoding headers when a block is provided' do
-      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
-      expect_any_instance_of(Net::HTTP).to receive(:request_get) do |_, _, headers, &block|
+      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.and_return(http_ok)
+      end.returns(http_ok)
 
       subject.request_with_redirects(dest, :get, 0) do
         # unused
@@ -385,7 +265,7 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'only makes a single HEAD request' do
-      expect_any_instance_of(Net::HTTP).to receive(:head).with(anything, anything).and_return(http_ok)
+      Net::HTTP.any_instance.expects(:head).with(anything, anything).returns(http_ok)
 
       subject.request_with_redirects(dest, :head, 0)
     end