puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

data/spec/unit/network/formats_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/formats'
@@ -102,14 +101,14 @@ describe "Puppet Network Format" do
     end
 
     it "should render by calling 'to_yaml' on the instance" do
-      instance = mock 'instance'
-      instance.expects(:to_yaml).returns "foo"
+      instance = double('instance')
+      expect(instance).to receive(:to_yaml).and_return("foo")
       expect(yaml.render(instance)).to eq("foo")
     end
 
     it "should render multiple instances by calling 'to_yaml' on the array" do
-      instances = [mock('instance')]
-      instances.expects(:to_yaml).returns "foo"
+      instances = [double('instance')]
+      expect(instances).to receive(:to_yaml).and_return("foo")
       expect(yaml.render_multiple(instances)).to eq("foo")
     end
 

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
@@ -6,6 +5,8 @@ require 'puppet/network/http/api/indirected_routes'
 require 'puppet/indirector_testing'
 require 'puppet_spec/network'
 
+RSpec::Matchers.define_negated_matcher :excluding, :include
+
 describe Puppet::Network::HTTP::API::IndirectedRoutes do
   include PuppetSpec::Network
 
@@ -16,7 +17,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
-    handler.stubs(:warn_if_near_expiration)
+    allow(handler).to receive(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
@@ -25,7 +26,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:params) { { :environment => "env" } }
 
     before do
-      handler.stubs(:handler).returns "foo"
+      allow(handler).to receive(:handler).and_return("foo")
     end
 
     around do |example|
@@ -139,28 +140,22 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "should not unescape the URI passed through in a call to check_authorization" do
       key_escaped = Puppet::Util.uri_encode("foo bar")
       uri_escaped = "#{master_url_prefix}/node/#{key_escaped}"
-      handler.expects(:check_authorization).with(anything, uri_escaped, anything)
-      _, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
+      expect(handler).to receive(:check_authorization).with(anything, uri_escaped, anything)
+      handler.uri2indirection("GET", uri_escaped, params)
     end
 
     it "when the environment is unknown should remove :environment from params passed to check_authorization and therefore fail" do
-      handler.expects(:check_authorization).with(anything,
-                                                 anything,
-                                                 Not(has_key(:environment)))
+      expect(handler).to receive(:check_authorization).with(anything,
+                                                            anything,
+                                                            excluding(:environment))
       expect(lambda { handler.uri2indirection("GET",
                                               "#{master_url_prefix}/node/bar",
                                               {:environment => 'bogus'}) }).to raise_error(not_found_error)
     end
 
     it "should not URI unescape the indirection key as passed through to a call to check_authorization" do
-      handler.expects(:check_authorization).with(anything,
-                                                 anything,
-                                                 all_of(
-                                                     has_entry(:environment,
-                                                               is_a(Puppet::Node::Environment)),
-                                                     has_entry(:environment,
-                                                               responds_with(:name,
-                                                                             :env))))
+      expect(handler).to receive(:check_authorization).with(anything, anything, hash_including(environment: be_a(Puppet::Node::Environment).and(have_attributes(name: :env))))
+
       handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
     end
 
@@ -171,7 +166,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
     before do
-      handler.stubs(:handler).returns "foo"
+      allow(handler).to receive(:handler).and_return("foo")
     end
 
     it "should include the environment in the query string of the URI" do
@@ -179,17 +174,17 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should include the correct url prefix if it is a ca request" do
-      request.stubs(:indirection_name).returns("certificate")
+      allow(request).to receive(:indirection_name).and_return("certificate")
       expect(handler.class.request_to_uri(request)).to eq("#{ca_url_prefix}/certificate/with%20spaces?environment=myenv&foo=bar")
     end
 
     it "should pluralize the indirection name if the method is 'search'" do
-      request.stubs(:method).returns :search
+      allow(request).to receive(:method).and_return(:search)
       expect(handler.class.request_to_uri(request).split("/")[3]).to eq("foos")
     end
 
     it "should add the query string to the URI" do
-      request.expects(:query_string).returns "query"
+      expect(request).to receive(:query_string).and_return("query")
       expect(handler.class.request_to_uri(request)).to match(/\&query$/)
     end
   end
@@ -212,7 +207,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should include the correct url prefix if it is a ca request" do
-      request.stubs(:indirection_name).returns("certificate")
+      allow(request).to receive(:indirection_name).and_return("certificate")
       expect(handler.class.request_to_uri_and_body(request).first).to eq("#{ca_url_prefix}/certificate/with%20spaces")
     end
 
@@ -227,7 +222,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       indirection.save(data, "my data")
       request = a_request_that_heads(data)
 
-      handler.expects(:check_authorization).raises(Puppet::Network::AuthorizationError.new("forbidden"))
+      expect(handler).to receive(:check_authorization).and_raise(Puppet::Network::AuthorizationError.new("forbidden"))
 
       expect {
         handler.call(request, response)
@@ -237,7 +232,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "should raise not_found_error if the indirection does not support remote requests" do
       request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
 
-      indirection.expects(:allow_remote_requests?).returns(false)
+      expect(indirection).to receive(:allow_remote_requests?).and_return(false)
 
       expect {
         handler.call(request, response)
@@ -271,7 +266,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => "application/json, text/pson")
-      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      allow(data).to receive(:to_json).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
       handler.call(request, response)
 
@@ -283,7 +278,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       data_string = "my data string"
       request = a_request_that_finds(data, :accept_header => "application/json")
-      indirection.expects(:find).returns(data_string)
+      expect(indirection).to receive(:find).and_return(data_string)
 
       handler.call(request, response)
 
@@ -317,7 +312,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
-      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      allow(data).to receive(:to_json).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
       handler.call(request, response)
 
@@ -329,8 +324,8 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
-      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
-      data.stubs(:to_pson).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
+      allow(data).to receive(:to_json).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      allow(data).to receive(:to_pson).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
 
       expect {
         handler.call(request, response)
@@ -348,7 +343,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
     it "should raise not_found_error when searching returns nil" do
       request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, application/json")
-      indirection.expects(:search).returns(nil)
+      expect(indirection).to receive(:search).and_return(nil)
 
       expect {
         handler.call(request, response)

data/spec/unit/network/http/api/master/v3/authorization_spec.rb

@@ -17,7 +17,7 @@ describe Puppet::Network::HTTP::API::Master::V3::Authorization do
       :params => { :authenticated => true, :node => "testing", :ip => "127.0.0.1" }
     })
 
-    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    allow(authz).to receive(:authconfig).and_return(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
 path /v3/environments
 method find
 allow *
@@ -39,7 +39,7 @@ allow *
       :params => { :authenticated => true, :node => "testing", :ip => "127.0.0.1" }
     })
 
-    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    allow(authz).to receive(:authconfig).and_return(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
 path /v3/environments
 method find
 auth any

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -175,7 +175,7 @@ describe Puppet::Network::HTTP::API::Master::V3::Environment do
   it "uses code_id from the catalog if it differs from the request" do
     request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
 
-    Puppet::Resource::Catalog.any_instance.stubs(:code_id).returns('67890')
+    allow_any_instance_of(Puppet::Resource::Catalog).to receive(:code_id).and_return('67890')
 
     subject.call(request, response)
 

data/spec/unit/network/http/api/master/v3/environments_spec.rb

@@ -33,11 +33,11 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for unlimited timeout" do
-    conf_stub = stub 'conf_stub'
-    conf_stub.expects(:environment_timeout).returns(Float::INFINITY)
+    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)
-    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
+    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
 
@@ -47,11 +47,11 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for integer timeout" do
-    conf_stub = stub 'conf_stub'
-    conf_stub.expects(:environment_timeout).returns(1)
+    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)
-    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
+    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
 
@@ -59,5 +59,4 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
-
 end

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

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet_spec/handler'
 require 'puppet/network/http'

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

@@ -1,9 +1,8 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "http compression" do
   let(:data)            { "uncompresseddata" }
-  let(:response)        { stub 'response' }
+  let(:response)        { double('response') }
   let(:compressed_zlib) { Zlib::Deflate.deflate(data) }
   let(:compressed_gzip) do
     str = StringIO.new
@@ -14,13 +13,13 @@ describe "http compression" do
   end
 
   def stubs_response_with(response, content_encoding, body)
-    response.stubs(:[]).with('content-encoding').returns(content_encoding)
-    response.stubs(:body).returns(body)
+    allow(response).to receive(:[]).with('content-encoding').and_return(content_encoding)
+    allow(response).to receive(:body).and_return(body)
   end
 
   describe "when zlib is not available" do
     before(:each) do
-      Puppet.features.stubs(:zlib?).returns false
+      allow(Puppet.features).to receive(:zlib?).and_return(false)
 
       require 'puppet/network/http/compression'
       class HttpUncompressor
@@ -39,12 +38,12 @@ describe "http compression" do
     end
 
     it "should not tamper the body" do
-      response = stub 'response', :body => data
+      response = double('response', :body => data)
       expect(@uncompressor.uncompress_body(response)).to eq(data)
     end
 
     it "should yield an identity uncompressor" do
-      response = stub 'response'
+      response = double('response')
       @uncompressor.uncompress(response) { |u|
         expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
       }
@@ -169,19 +168,19 @@ describe "http compression" do
 
       it "should close the underlying adapter" do
         stubs_response_with(response, 'identity', data)
-        adapter = stub_everything 'adapter'
-        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
+        adapter = double('adapter')
+        expect(Puppet::Network::HTTP::Compression::IdentityAdapter).to receive(:new).and_return(adapter)
 
-        adapter.expects(:close)
+        expect(adapter).to receive(:close)
         uncompressor.uncompress(response) { |u| }
       end
 
       it "should close the underlying adapter if the yielded block raises" do
         stubs_response_with(response, 'identity', data)
-        adapter = stub_everything 'adapter'
-        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
+        adapter = double('adapter')
+        expect(Puppet::Network::HTTP::Compression::IdentityAdapter).to receive(:new).and_return(adapter)
 
-        adapter.expects(:close)
+        expect(adapter).to receive(:close)
         expect {
           uncompressor.uncompress(response) { |u| raise ArgumentError, "whoops" }
         }.to raise_error(ArgumentError, "whoops")
@@ -190,7 +189,7 @@ describe "http compression" do
 
     describe "zlib adapter" do
       it "should initialize the underlying inflater with gzip/zlib header parsing" do
-        Zlib::Inflate.expects(:new).with(15+32)
+        expect(Zlib::Inflate).to receive(:new).with(15 + 32)
 
         Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
       end
@@ -203,7 +202,7 @@ describe "http compression" do
 
       it "should try a 'regular' inflater on Zlib::DataError" do
         inflater = Zlib::Inflate.new(15 + 32)
-        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        expect(inflater).to receive(:inflate).and_raise(Zlib::DataError.new("not a zlib stream"))
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
 
         expect(adapter.uncompress(compressed_zlib)).to eq(data)
@@ -211,25 +210,25 @@ describe "http compression" do
 
       it "should raise the error the second time" do
         inflater = Zlib::Inflate.new(15 + 32)
-        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        expect(inflater).to receive(:inflate).and_raise(Zlib::DataError.new("not a zlib stream"))
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
 
         expect { adapter.uncompress("this is not compressed data") }.to raise_error(Zlib::DataError, /incorrect header check/)
       end
 
       it "should finish and close the stream" do
-        inflater = stub 'inflater'
-        inflater.expects(:finish)
-        inflater.expects(:close)
+        inflater = double('inflater')
+        expect(inflater).to receive(:finish)
+        expect(inflater).to receive(:close)
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
 
         adapter.close
       end
 
       it "should close the stream even if finish raises" do
-        inflater = stub 'inflater'
-        inflater.expects(:finish).raises(Zlib::BufError)
-        inflater.expects(:close)
+        inflater = double('inflater')
+        expect(inflater).to receive(:finish).and_raise(Zlib::BufError)
+        expect(inflater).to receive(:close)
 
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
         expect {

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

@@ -1,11 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http/connection'
 require 'puppet_spec/validators'
 require 'puppet/test_ca'
 
 describe Puppet::Network::HTTP::Connection do
-
   let (:host) { "me" }
   let (:port) { 54321 }
   subject { Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator) }
@@ -55,7 +53,7 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a verifier" do
-        verifier = Puppet::SSL::Verifier.new('fqdn', stub('ssl_context'))
+        verifier = Puppet::SSL::Verifier.new('fqdn', double('ssl_context'))
         conn = Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true, :verifier => verifier)
 
         expect(conn.verifier).to eq(verifier)
@@ -80,7 +78,10 @@ describe Puppet::Network::HTTP::Connection do
       :request_post => "param: value" }.each do |method,body|
       context "##{method}" do
         it "should yield to the block" do
-          Net::HTTP.any_instance.stubs(method).yields.returns(httpok)
+          allow_any_instance_of(Net::HTTP).to receive(method) do |_, *_, &block|
+            block.call()
+            httpok
+          end
 
           block_executed = false
           subject.send(method, "/foo", body) do |response|
@@ -101,7 +102,7 @@ describe Puppet::Network::HTTP::Connection do
     let (:httpredirection) do
       response = Net::HTTPFound.new('1.1', 302, 'Moved Temporarily')
       response['location'] = "#{other_site.addr}/#{other_path}"
-      response.stubs(:read_body).returns("This resource has moved")
+      allow(response).to receive(:read_body).and_return("This resource has moved")
       response
     end
 
@@ -111,24 +112,23 @@ describe Puppet::Network::HTTP::Connection do
     end
 
     it "should redirect to the final resource location" do
-      http = stub('http')
-      http.stubs(:request).returns(httpredirection).then.returns(httpok)
+      http = double('http')
+      allow(http).to receive(:request).and_return(httpredirection, httpok)
 
-      seq = sequence('redirection')
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).yields(http).in_sequence(seq)
-      pool.expects(:with_connection).with(other_site, anything).yields(http).in_sequence(seq)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http).ordered
+      expect(pool).to receive(:with_connection).with(other_site, anything).and_yield(http).ordered
 
       conn = create_connection(site, :verify => verify)
       conn.get('/foo')
     end
 
     def expects_redirection(conn, &block)
-      http = stub('http')
-      http.stubs(:request).returns(httpredirection)
+      http = double('http')
+      allow(http).to receive(:request).and_return(httpredirection)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
       pool
     end
 
@@ -142,7 +142,7 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 0)
 
       pool = expects_redirection(conn)
-      pool.expects(:with_connection).with(other_site, anything).never
+      expect(pool).not_to receive(:with_connection).with(other_site, anything)
 
       expects_limit_exceeded(conn)
     end
@@ -151,7 +151,7 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 1)
 
       pool = expects_redirection(conn)
-      pool.expects(:with_connection).with(other_site, anything).once
+      expect(pool).to receive(:with_connection).with(other_site, anything).once
 
       expects_limit_exceeded(conn)
     end
@@ -160,14 +160,14 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 3)
 
       pool = expects_redirection(conn)
-      pool.expects(:with_connection).with(other_site, anything).times(3)
+      expect(pool).to receive(:with_connection).with(other_site, anything).exactly(3).times
 
       expects_limit_exceeded(conn)
     end
   end
 
   context "when response indicates an overloaded server" do
-    let(:http) { stub('http') }
+    let(:http) { double('http') }
     let(:site) { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
     let(:verify) { Puppet::SSL::Validator.no_validator }
     let(:httpunavailable) { Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable') }
@@ -186,10 +186,10 @@ describe Puppet::Network::HTTP::Connection do
     end
 
     it "should return a 503 response if Retry-After is not set" do
-      http.stubs(:request).returns(httpunavailable)
+      allow(http).to receive(:request).and_return(httpunavailable)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
 
       result = subject.get('/foo')
 
@@ -198,10 +198,10 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should return a 503 response if Retry-After is not convertible to an Integer or RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'foo'
-      http.stubs(:request).returns(httpunavailable)
+      allow(http).to receive(:request).and_return(httpunavailable)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
 
       result = subject.get('/foo')
 
@@ -210,12 +210,12 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep and retry if Retry-After is an Integer" do
       httpunavailable['Retry-After'] = '42'
-      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).twice.yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
 
-      ::Kernel.expects(:sleep).with(42)
+      expect(::Kernel).to receive(:sleep).with(42)
 
       result = subject.get('/foo')
 
@@ -224,15 +224,15 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep and retry if Retry-After is an RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'Wed, 13 Apr 2005 15:18:05 GMT'
-      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
 
       now = DateTime.new(2005, 4, 13, 8, 17, 5, '-07:00')
-      DateTime.stubs(:now).returns(now)
+      allow(DateTime).to receive(:now).and_return(now)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).twice.yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
 
-      ::Kernel.expects(:sleep).with(60)
+      expect(::Kernel).to receive(:sleep).with(60)
 
       result = subject.get('/foo')
 
@@ -241,13 +241,13 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep for no more than the Puppet runinterval" do
       httpunavailable['Retry-After'] = '60'
-      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
       Puppet[:runinterval] = 30
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).twice.yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
 
-      ::Kernel.expects(:sleep).with(30)
+      expect(::Kernel).to receive(:sleep).with(30)
 
       subject.get('/foo')
     end
@@ -284,17 +284,17 @@ describe Puppet::Network::HTTP::Connection do
   end
 
   def expect_request_with_basic_auth
-    Net::HTTP.any_instance.expects(:request).with do |request|
+    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
       expect(request['authorization']).to match(/^Basic/)
-    end.returns(httpok)
+    end.and_return(httpok)
   end
 
   it "sets HTTP User-Agent header" do
     puppet_ua = "Puppet/#{Puppet.version} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
 
-    Net::HTTP.any_instance.expects(:request).with do |request|
+    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
       expect(request['User-Agent']).to eq(puppet_ua)
-    end.returns(httpok)
+    end.and_return(httpok)
 
     subject.get('/path')
   end