puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

data/spec/unit/network/formats_spec.rb

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

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
@@ -5,8 +6,6 @@ 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
 
@@ -17,7 +16,7 @@ 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)
+    handler.stubs(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
@@ -26,7 +25,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:params) { { :environment => "env" } }
 
     before do
-      allow(handler).to receive(:handler).and_return("foo")
+      handler.stubs(:handler).returns "foo"
     end
 
     around do |example|
@@ -140,22 +139,28 @@ 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}"
-      expect(handler).to receive(:check_authorization).with(anything, uri_escaped, anything)
-      handler.uri2indirection("GET", uri_escaped, params)
+      handler.expects(: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
-      expect(handler).to receive(:check_authorization).with(anything,
-                                                            anything,
-                                                            excluding(:environment))
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 Not(has_key(: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
-      expect(handler).to receive(:check_authorization).with(anything, anything, hash_including(environment: be_a(Puppet::Node::Environment).and(have_attributes(name: :env))))
-
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 all_of(
+                                                     has_entry(:environment,
+                                                               is_a(Puppet::Node::Environment)),
+                                                     has_entry(:environment,
+                                                               responds_with(:name,
+                                                                             :env))))
       handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
     end
 
@@ -166,7 +171,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
-      allow(handler).to receive(:handler).and_return("foo")
+      handler.stubs(:handler).returns "foo"
     end
 
     it "should include the environment in the query string of the URI" do
@@ -174,17 +179,17 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should include the correct url prefix if it is a ca request" do
-      allow(request).to receive(:indirection_name).and_return("certificate")
+      request.stubs(:indirection_name).returns("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
-      allow(request).to receive(:method).and_return(:search)
+      request.stubs(:method).returns :search
       expect(handler.class.request_to_uri(request).split("/")[3]).to eq("foos")
     end
 
     it "should add the query string to the URI" do
-      expect(request).to receive(:query_string).and_return("query")
+      request.expects(:query_string).returns "query"
       expect(handler.class.request_to_uri(request)).to match(/\&query$/)
     end
   end
@@ -207,7 +212,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should include the correct url prefix if it is a ca request" do
-      allow(request).to receive(:indirection_name).and_return("certificate")
+      request.stubs(:indirection_name).returns("certificate")
       expect(handler.class.request_to_uri_and_body(request).first).to eq("#{ca_url_prefix}/certificate/with%20spaces")
     end
 
@@ -222,7 +227,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       indirection.save(data, "my data")
       request = a_request_that_heads(data)
 
-      expect(handler).to receive(:check_authorization).and_raise(Puppet::Network::AuthorizationError.new("forbidden"))
+      handler.expects(:check_authorization).raises(Puppet::Network::AuthorizationError.new("forbidden"))
 
       expect {
         handler.call(request, response)
@@ -232,7 +237,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"))
 
-      expect(indirection).to receive(:allow_remote_requests?).and_return(false)
+      indirection.expects(:allow_remote_requests?).returns(false)
 
       expect {
         handler.call(request, response)
@@ -266,7 +271,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")
-      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')
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
       handler.call(request, response)
 
@@ -278,7 +283,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")
-      expect(indirection).to receive(:find).and_return(data_string)
+      indirection.expects(:find).returns(data_string)
 
       handler.call(request, response)
 
@@ -312,7 +317,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")
-      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')
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
       handler.call(request, response)
 
@@ -324,8 +329,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")
-      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')
+      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')
 
       expect {
         handler.call(request, response)
@@ -343,7 +348,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")
-      expect(indirection).to receive(:search).and_return(nil)
+      indirection.expects(:search).returns(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" }
     })
 
-    allow(authz).to receive(:authconfig).and_return(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    authz.stubs(:authconfig).returns(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" }
     })
 
-    allow(authz).to receive(:authconfig).and_return(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    authz.stubs(:authconfig).returns(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")
 
-    allow_any_instance_of(Puppet::Resource::Catalog).to receive(:code_id).and_return('67890')
+    Puppet::Resource::Catalog.any_instance.stubs(:code_id).returns('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 = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(Float::INFINITY)
+    conf_stub = stub 'conf_stub'
+    conf_stub.expects(:environment_timeout).returns(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)
+    env_loader.expects(:get_conf).with(:production).returns(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 = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(1)
+    conf_stub = stub 'conf_stub'
+    conf_stub.expects(:environment_timeout).returns(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)
+    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
     handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
@@ -59,4 +59,5 @@ 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,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 require 'puppet_spec/handler'
 require 'puppet/network/http'

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

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

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

@@ -1,9 +1,11 @@
+#! /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) }
@@ -62,6 +64,94 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
+  shared_examples_for 'ssl verifier' do
+    include PuppetSpec::Files
+
+    let (:host) { "my_server" }
+    let (:port) { 8140 }
+
+    before :all do
+      WebMock.disable!
+    end
+
+    after :all do
+      WebMock.enable!
+    end
+
+    it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet::Util::Platform.windows? do
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => ConstantErrorValidator.new(:fails_with => 'certificate verify failed',
+                                              :error_string => 'shady looking signature'))
+
+      expect do
+        connection.get('request')
+      end.to raise_error(Puppet::Error, "certificate verify failed: [shady looking signature]")
+    end
+
+    it "should provide a helpful error message when hostname was not match with server certificate", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
+      Puppet[:confdir] = tmpdir('conf')
+
+      connection = Puppet::Network::HTTP::Connection.new(
+      host, port,
+      :verify => ConstantErrorValidator.new(
+        :fails_with => 'hostname was not match with server certificate',
+        :peer_certs => [Puppet::TestCa.new.generate('not_my_server',
+                                                    :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:not_my_server')[:cert]]))
+
+      expect do
+        connection.get('request')
+      end.to raise_error(Puppet::Error) do |error|
+        error.message =~ /\AServer hostname 'my_server' did not match server certificate; expected one of (.+)/
+        expect($1.split(', ')).to match_array(%w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server])
+      end
+    end
+
+    it "should pass along the error message otherwise" do
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => ConstantErrorValidator.new(:fails_with => 'some other message'))
+
+      expect do
+        connection.get('request')
+      end.to raise_error(/some other message/)
+    end
+
+    it "should check all peer certificates for upcoming expiration", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
+      Puppet[:confdir] = tmpdir('conf')
+      cert = Puppet::TestCa.new.generate('server',
+                                         :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:server')[:cert]
+
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => NoProblemsValidator.new(cert))
+
+      Net::HTTP.any_instance.stubs(:start)
+      Net::HTTP.any_instance.stubs(:request).returns(httpok)
+      Puppet::Network::HTTP::Pool.any_instance.stubs(:setsockopts)
+
+      connection.get('request')
+    end
+  end
+
+  context "when using single use HTTPS connections", :unless => RUBY_PLATFORM == 'java' do
+    it_behaves_like 'ssl verifier' do
+    end
+  end
+
+  context "when using persistent HTTPS connections", :unless => RUBY_PLATFORM == 'java' do
+    around :each do |example|
+      pool = Puppet::Network::HTTP::Pool.new
+      Puppet.override(:http_pool => pool) do
+        example.run
+      end
+      pool.close
+    end
+
+    it_behaves_like 'ssl verifier' do
+    end
+  end
+
   context "when response is a redirect" do
     let (:site)       { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
     let (:other_site) { Puppet::Network::HTTP::Site.new('http', 'redirected', 9292) }
@@ -71,7 +161,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}"
-      allow(response).to receive(:read_body).and_return("This resource has moved")
+      response.stubs(:read_body).returns("This resource has moved")
       response
     end
 
@@ -81,23 +171,24 @@ describe Puppet::Network::HTTP::Connection do
     end
 
     it "should redirect to the final resource location" do
-      http = double('http')
-      allow(http).to receive(:request).and_return(httpredirection, httpok)
+      http = stub('http')
+      http.stubs(:request).returns(httpredirection).then.returns(httpok)
 
+      seq = sequence('redirection')
       pool = Puppet.lookup(:http_pool)
-      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
+      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)
 
       conn = create_connection(site, :verify => verify)
       conn.get('/foo')
     end
 
     def expects_redirection(conn, &block)
-      http = double('http')
-      allow(http).to receive(:request).and_return(httpredirection)
+      http = stub('http')
+      http.stubs(:request).returns(httpredirection)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+      pool.expects(:with_connection).with(site, anything).yields(http)
       pool
     end
 
@@ -111,7 +202,7 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 0)
 
       pool = expects_redirection(conn)
-      expect(pool).not_to receive(:with_connection).with(other_site, anything)
+      pool.expects(:with_connection).with(other_site, anything).never
 
       expects_limit_exceeded(conn)
     end
@@ -120,7 +211,7 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 1)
 
       pool = expects_redirection(conn)
-      expect(pool).to receive(:with_connection).with(other_site, anything).once
+      pool.expects(:with_connection).with(other_site, anything).once
 
       expects_limit_exceeded(conn)
     end
@@ -129,14 +220,14 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 3)
 
       pool = expects_redirection(conn)
-      expect(pool).to receive(:with_connection).with(other_site, anything).exactly(3).times
+      pool.expects(:with_connection).with(other_site, anything).times(3)
 
       expects_limit_exceeded(conn)
     end
   end
 
   context "when response indicates an overloaded server" do
-    let(:http) { double('http') }
+    let(:http) { stub('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') }
@@ -155,10 +246,10 @@ describe Puppet::Network::HTTP::Connection do
     end
 
     it "should return a 503 response if Retry-After is not set" do
-      allow(http).to receive(:request).and_return(httpunavailable)
+      http.stubs(:request).returns(httpunavailable)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+      pool.expects(:with_connection).with(site, anything).yields(http)
 
       result = subject.get('/foo')
 
@@ -167,10 +258,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'
-      allow(http).to receive(:request).and_return(httpunavailable)
+      http.stubs(:request).returns(httpunavailable)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+      pool.expects(:with_connection).with(site, anything).yields(http)
 
       result = subject.get('/foo')
 
@@ -179,12 +270,12 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep and retry if Retry-After is an Integer" do
       httpunavailable['Retry-After'] = '42'
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
+      pool.expects(:with_connection).with(site, anything).twice.yields(http)
 
-      expect(::Kernel).to receive(:sleep).with(42)
+      ::Kernel.expects(:sleep).with(42)
 
       result = subject.get('/foo')
 
@@ -193,15 +284,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'
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
 
       now = DateTime.new(2005, 4, 13, 8, 17, 5, '-07:00')
-      allow(DateTime).to receive(:now).and_return(now)
+      DateTime.stubs(:now).returns(now)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
+      pool.expects(:with_connection).with(site, anything).twice.yields(http)
 
-      expect(::Kernel).to receive(:sleep).with(60)
+      ::Kernel.expects(:sleep).with(60)
 
       result = subject.get('/foo')
 
@@ -210,13 +301,13 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep for no more than the Puppet runinterval" do
       httpunavailable['Retry-After'] = '60'
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
       Puppet[:runinterval] = 30
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
+      pool.expects(:with_connection).with(site, anything).twice.yields(http)
 
-      expect(::Kernel).to receive(:sleep).with(30)
+      ::Kernel.expects(:sleep).with(30)
 
       subject.get('/foo')
     end
@@ -253,17 +344,17 @@ describe Puppet::Network::HTTP::Connection do
   end
 
   def expect_request_with_basic_auth
-    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
+    Net::HTTP.any_instance.expects(:request).with do |request|
       expect(request['authorization']).to match(/^Basic/)
-    end.and_return(httpok)
+    end.returns(httpok)
   end
 
   it "sets HTTP User-Agent header" do
     puppet_ua = "Puppet/#{Puppet.version} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
 
-    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
+    Net::HTTP.any_instance.expects(:request).with do |request|
       expect(request['User-Agent']).to eq(puppet_ua)
-    end.and_return(httpok)
+    end.returns(httpok)
 
     subject.get('/path')
   end