puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 
@@ -16,27 +15,27 @@ describe "Puppet::Network::HTTP::Rack", :if => Puppet.features.rack? do
 
     it "should create a Request object" do
       request = Rack::Request.new(@env)
-      Rack::Request.expects(:new).returns request
+      expect(Rack::Request).to receive(:new).and_return(request)
       @linted.call(@env)
     end
 
     it "should create a Response object" do
-      Rack::Response.expects(:new).returns stub_everything
+      expect(Rack::Response).to receive(:new).and_return(double('rack response', :[]= => nil, :status= => nil, :write => nil, :finish => nil))
       @app.call(@env) # can't lint when Rack::Response is a stub
     end
 
     it "should let RackREST process the request" do
-      Puppet::Network::HTTP::RackREST.any_instance.expects(:process).once
+      expect_any_instance_of(Puppet::Network::HTTP::RackREST).to receive(:process).once
       @linted.call(@env)
     end
 
     it "should catch unhandled exceptions from RackREST" do
-      Puppet::Network::HTTP::RackREST.any_instance.expects(:process).raises(ArgumentError, 'test error')
+      expect_any_instance_of(Puppet::Network::HTTP::RackREST).to receive(:process).and_raise(ArgumentError, 'test error')
       expect { @linted.call(@env) }.not_to raise_error
     end
 
     it "should finish() the Response" do
-      Rack::Response.any_instance.expects(:finish).once
+      expect_any_instance_of(Rack::Response).to receive(:finish).once
       @app.call(@env) # can't lint when finish is a stub
     end
   end

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

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

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

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/handler'
@@ -17,14 +15,14 @@ describe Puppet::Network::HTTP::Response do
 
   context "when passed a response body" do
     it "passes the status code and body to the handler" do
-      handler.expects(:set_response).with(response, body_utf8, 200)
+      expect(handler).to receive(:set_response).with(response, body_utf8, 200)
 
       subject.respond_with(200, 'application/json', body_utf8)
     end
 
     it "accepts a File body" do
       file = tmpfile('response_spec')
-      handler.expects(:set_response).with(response, file, 200)
+      expect(handler).to receive(:set_response).with(response, file, 200)
 
       subject.respond_with(200, 'application/octet-stream', file)
     end
@@ -32,14 +30,14 @@ describe Puppet::Network::HTTP::Response do
 
   context "when passed a content type" do
     it "accepts a mime string" do
-      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+      expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
 
       subject.respond_with(200, 'application/json', body_utf8)
     end
 
     it "accepts a format object" do
       formatter = Puppet::Network::FormatHandler.format(:json)
-      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+      expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
 
       subject.respond_with(200, formatter, body_utf8)
     end
@@ -51,7 +49,7 @@ describe Puppet::Network::HTTP::Response do
         body_binary = [0xDEADCAFE].pack('L')
 
         formatter = Puppet::Network::FormatHandler.format(:binary)
-        handler.expects(:set_content_type).with(response, 'application/octet-stream')
+        expect(handler).to receive(:set_content_type).with(response, 'application/octet-stream')
 
         subject.respond_with(200, formatter, body_binary)
       end
@@ -63,14 +61,14 @@ describe Puppet::Network::HTTP::Response do
       it "sets the charset to UTF-8 for content already in that format" do
         body_pem = "BEGIN CERTIFICATE".encode('UTF-8')
 
-        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
+        expect(handler).to receive(:set_content_type).with(response, 'text/plain; charset=utf-8')
 
         subject.respond_with(200, formatter, body_pem)
       end
 
       it "encodes the content to UTF-8 for content not already in UTF-8" do
-        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
-        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+        expect(handler).to receive(:set_content_type).with(response, 'text/plain; charset=utf-8')
+        expect(handler).to receive(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
 
         subject.respond_with(200, formatter, body_shift_jis)
       end
@@ -86,14 +84,14 @@ describe Puppet::Network::HTTP::Response do
       let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
 
       it "sets the charset to UTF-8 for content already in that format" do
-        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+        expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
 
         subject.respond_with(200, formatter, body_utf8)
       end
 
       it "encodes the content to UTF-8 for content not already in UTF-8" do
-        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
-        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+        expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
+        expect(handler).to receive(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
 
         subject.respond_with(200, formatter, body_shift_jis)
       end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector_testing'
 

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

@@ -1,10 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
 
 describe Puppet::Network::HTTP::Session do
-  let(:connection) { stub('connection') }
+  let(:connection) { double('connection') }
 
   def create_session(connection, expiration_time = nil)
     expiration_time ||= Time.now + 60 * 60

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

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

data/spec/unit/network/http/webrick/rest_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'webrick'
@@ -11,20 +10,20 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
   describe "when receiving a request" do
     before do
-      @request     = stub('webrick http request', :query => {},
-                          :query_string => 'environment=production',
-                          :peeraddr => %w{eh boo host ip},
-                          :request_method => 'GET',
-                          :client_cert => nil)
-      @response    = mock('webrick http response')
-      @model_class = stub('indirected model class')
-      @webrick     = stub('webrick http server', :mount => true, :[] => {})
-      Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
+      @request     = double('webrick http request', :query => {},
+                            :query_string => 'environment=production',
+                            :peeraddr => %w{eh boo host ip},
+                            :request_method => 'GET',
+                            :client_cert => nil)
+      @response    = double('webrick http response')
+      @model_class = double('indirected model class')
+      @webrick     = double('webrick http server', :mount => true, :[] => {})
+      allow(Puppet::Indirector::Indirection).to receive(:model).with(:foo).and_return(@model_class)
       @handler = Puppet::Network::HTTP::WEBrickREST.new(@webrick)
     end
 
     it "should delegate its :service method to its :process method" do
-      @handler.expects(:process).with(@request, @response).returns "stuff"
+      expect(@handler).to receive(:process).with(@request, @response).and_return("stuff")
       expect(@handler.service(@request, @response)).to eq("stuff")
     end
 
@@ -32,7 +31,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
       let(:fake_request) { {"Foo" => "bar", "BAZ" => "bam" } }
 
       it "should iterate over the request object using #each" do
-        fake_request.expects(:each)
+        expect(fake_request).to receive(:each)
         @handler.headers(fake_request)
       end
 
@@ -44,48 +43,48 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
     describe "when using the Handler interface" do
       it "should use the request method as the http method" do
-        @request.expects(:request_method).returns "FOO"
+        expect(@request).to receive(:request_method).and_return("FOO")
         expect(@handler.http_method(@request)).to eq("FOO")
       end
 
       it "should return the request path as the path" do
-        @request.expects(:path).returns "/foo/bar"
+        expect(@request).to receive(:path).and_return("/foo/bar")
         expect(@handler.path(@request)).to eq("/foo/bar")
       end
 
       it "should return the request body as the body" do
-        @request.stubs(:request_method).returns "POST"
-        @request.expects(:body).returns "my body"
+        allow(@request).to receive(:request_method).and_return("POST")
+        expect(@request).to receive(:body).and_return("my body")
         expect(@handler.body(@request)).to eq("my body")
       end
 
       it "should set the response's 'content-type' header when setting the content type" do
-        @response.expects(:[]=).with("content-type", "text/html")
+        expect(@response).to receive(:[]=).with("content-type", "text/html")
         @handler.set_content_type(@response, "text/html")
       end
 
       it "should set the status and body on the response when setting the response for a successful query" do
-        @response.expects(:status=).with 200
-        @response.expects(:body=).with "mybody"
+        expect(@response).to receive(:status=).with(200)
+        expect(@response).to receive(:body=).with("mybody")
 
         @handler.set_response(@response, "mybody", 200)
       end
 
       it "serves a file" do
-        stat = stub 'stat', :size => 100
-        @file = stub 'file', :stat => stat, :path => "/tmp/path"
-        @file.stubs(:is_a?).with(File).returns(true)
+        stat = double('stat', :size => 100)
+        @file = double('file', :stat => stat, :path => "/tmp/path")
+        allow(@file).to receive(:is_a?).with(File).and_return(true)
 
-        @response.expects(:[]=).with('content-length', 100)
-        @response.expects(:status=).with 200
-        @response.expects(:body=).with @file
+        expect(@response).to receive(:[]=).with('content-length', 100)
+        expect(@response).to receive(:status=).with(200)
+        expect(@response).to receive(:body=).with(@file)
 
         @handler.set_response(@response, @file, 200)
       end
 
       it "should set the status and message on the response when setting the response for a failed query" do
-        @response.expects(:status=).with 400
-        @response.expects(:body=).with "mybody"
+        expect(@response).to receive(:status=).with(400)
+        expect(@response).to receive(:body=).with("mybody")
 
         @handler.set_response(@response, "mybody", 400)
       end
@@ -98,7 +97,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
       end
 
       def a_request_querying(query_data)
-        @request.expects(:query).returns(query_of(query_data))
+        expect(@request).to receive(:query).and_return(query_of(query_data))
         @request
       end
 
@@ -110,7 +109,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
       it "has no parameters when there is no query string" do
         only_server_side_information = [:authenticated, :ip, :node]
-        @request.stubs(:query).returns(nil)
+        allow(@request).to receive(:query).and_return(nil)
 
         result = @handler.params(@request)
 
@@ -118,8 +117,8 @@ describe Puppet::Network::HTTP::WEBrickREST do
       end
 
       it "should prefer duplicate params from the body over the query string" do
-        @request.stubs(:request_method).returns "PUT"
-        @request.stubs(:query).returns(WEBrick::HTTPUtils.parse_query("foo=bar&environment=posted_env"))
+        allow(@request).to receive(:request_method).and_return("PUT")
+        allow(@request).to receive(:query).and_return(WEBrick::HTTPUtils.parse_query("foo=bar&environment=posted_env"))
         expect(@handler.params(@request)[:environment]).to eq("posted_env")
       end
 
@@ -178,7 +177,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
       it "should not allow clients to set the node via the request parameters" do
         request = a_request_querying("node" => "foo")
-        @handler.stubs(:resolve_node)
+        allow(@handler).to receive(:resolve_node)
 
         expect(@handler.params(request)[:node]).to be_nil
       end
@@ -190,39 +189,39 @@ describe Puppet::Network::HTTP::WEBrickREST do
       end
 
       it "should pass the client's ip address to model find" do
-        @request.stubs(:peeraddr).returns(%w{noidea dunno hostname ipaddress})
+        allow(@request).to receive(:peeraddr).and_return(%w{noidea dunno hostname ipaddress})
         expect(@handler.params(@request)[:ip]).to eq("ipaddress")
       end
 
       it "should set 'authenticated' to true if a certificate is present" do
-        cert = stub 'cert', :subject => [%w{CN host.domain.com}]
-        @request.stubs(:client_cert).returns cert
+        cert = double('cert', :subject => [%w{CN host.domain.com}])
+        allow(@request).to receive(:client_cert).and_return(cert)
         expect(@handler.params(@request)[:authenticated]).to be_truthy
       end
 
       it "should set 'authenticated' to false if no certificate is present" do
-        @request.stubs(:client_cert).returns nil
+        allow(@request).to receive(:client_cert).and_return(nil)
         expect(@handler.params(@request)[:authenticated]).to be_falsey
       end
 
       it "should pass the client's certificate name to model method if a certificate is present" do
-        @request.stubs(:client_cert).returns(certificate_with_subject("/CN=host.domain.com"))
+        allow(@request).to receive(:client_cert).and_return(certificate_with_subject("/CN=host.domain.com"))
 
         expect(@handler.params(@request)[:node]).to eq("host.domain.com")
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
-        @request.stubs(:client_cert).returns nil
+        allow(@request).to receive(:client_cert).and_return(nil)
 
-        @handler.expects(:resolve_node).returns(:resolved_node)
+        expect(@handler).to receive(:resolve_node).and_return(:resolved_node)
 
         expect(@handler.params(@request)[:node]).to eq(:resolved_node)
       end
 
       it "should resolve the node name with an ip address look-up if CN parsing fails" do
-        @request.stubs(:client_cert).returns(certificate_with_subject("/C=company"))
+        allow(@request).to receive(:client_cert).and_return(certificate_with_subject("/C=company"))
 
-        @handler.expects(:resolve_node).returns(:resolved_node)
+        expect(@handler).to receive(:resolve_node).and_return(:resolved_node)
 
         expect(@handler.params(@request)[:node]).to eq(:resolved_node)
       end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet/network/http/webrick'
@@ -17,34 +16,34 @@ describe Puppet::Network::HTTP::WEBrick do
   let(:server) { Puppet::Network::HTTP::WEBrick.new }
   let(:localcacert) { make_absolute("/ca/crt") }
   let(:ssl_server_ca_auth) { make_absolute("/ca/ssl_server_auth_file") }
-  let(:key) { stub 'key', :content => "mykey" }
-  let(:cert) { stub 'cert', :content => "mycert" }
-  let(:host) { stub 'host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore" }
+  let(:key) { double('key', :content => "mykey") }
+  let(:cert) { double('cert', :content => "mycert") }
+  let(:host) { double('host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore") }
 
   let(:mock_ssl_context) do
-    stub('ssl_context', :ciphers= => nil)
+    double('ssl_context', :ciphers= => nil)
   end
 
-  let(:socket) { mock('socket') }
+  let(:socket) { double('socket') }
   let(:mock_webrick) do
-    server = stub('webrick',
+    server = double('webrick',
                   :[] => {},
                   :listeners => [],
                   :status => :Running,
                   :mount => nil,
                   :shutdown => nil,
                   :ssl_context => mock_ssl_context)
-    server.stubs(:start).yields(socket)
-    IO.stubs(:select).with([socket], nil, nil, anything).returns(true)
-    socket.stubs(:accept)
-    server.stubs(:run).with(socket)
+    allow(server).to receive(:start).and_yield(socket)
+    allow(IO).to receive(:select).with([socket], nil, nil, anything).and_return(true)
+    allow(socket).to receive(:accept)
+    allow(server).to receive(:run).with(socket)
     server
   end
 
   before :each do
-    WEBrick::HTTPServer.stubs(:new).returns(mock_webrick)
-    Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns cert
-    Puppet::SSL::Host.stubs(:localhost).returns host
+    allow(WEBrick::HTTPServer).to receive(:new).and_return(mock_webrick)
+    allow(Puppet::SSL::Certificate.indirection).to receive(:find).with('ca').and_return(cert)
+    allow(Puppet::SSL::Host).to receive(:localhost).and_return(host)
   end
 
   describe "when turning on listening" do
@@ -54,37 +53,35 @@ describe Puppet::Network::HTTP::WEBrick do
     end
 
     it "should tell webrick to listen on the specified address and port" do
-      WEBrick::HTTPServer.expects(:new).with(
-        has_entries(:Port => 31337, :BindAddress => "127.0.0.1")
-      ).returns(mock_webrick)
+      expect(WEBrick::HTTPServer).to receive(:new).with(
+        hash_including(:Port => 31337, :BindAddress => "127.0.0.1")
+      ).and_return(mock_webrick)
       server.listen(address, port)
     end
 
     it "should not perform reverse lookups" do
-      WEBrick::HTTPServer.expects(:new).with(
-        has_entry(:DoNotReverseLookup => true)
-      ).returns(mock_webrick)
-      BasicSocket.expects(:do_not_reverse_lookup=).with(true)
+      expect(WEBrick::HTTPServer).to receive(:new).with(
+        hash_including(:DoNotReverseLookup => true)
+      ).and_return(mock_webrick)
+      expect(BasicSocket).to receive(:do_not_reverse_lookup=).with(true)
 
       server.listen(address, port)
     end
 
     it "should configure a logger for webrick" do
-      server.expects(:setup_logger).returns(:Logger => :mylogger)
+      expect(server).to receive(:setup_logger).and_return(:Logger => :mylogger)
 
-      WEBrick::HTTPServer.expects(:new).with {|args|
-        args[:Logger] == :mylogger
-      }.returns(mock_webrick)
+      expect(WEBrick::HTTPServer).to receive(:new) do |args|
+        expect(args[:Logger]).to eq(:mylogger)
+      end.and_return(mock_webrick)
 
       server.listen(address, port)
     end
 
     it "should configure SSL for webrick" do
-      server.expects(:setup_ssl).returns(:Ssl => :testing, :Other => :yay)
+      expect(server).to receive(:setup_ssl).and_return(:Ssl => :testing, :Other => :yay)
 
-      WEBrick::HTTPServer.expects(:new).with {|args|
-        args[:Ssl] == :testing and args[:Other] == :yay
-      }.returns(mock_webrick)
+      expect(WEBrick::HTTPServer).to receive(:new).with(hash_including(:Ssl => :testing, :Other => :yay)).and_return(mock_webrick)
 
       server.listen(address, port)
     end
@@ -95,7 +92,7 @@ describe Puppet::Network::HTTP::WEBrick do
     end
 
     it "is passed a yet to be accepted socket" do
-      socket.expects(:accept)
+      expect(socket).to receive(:accept)
 
       server.listen(address, port)
       server.unlisten
@@ -104,7 +101,7 @@ describe Puppet::Network::HTTP::WEBrick do
     describe "when the REST protocol is requested" do
       it "should register the REST handler at /" do
         # We don't care about the options here.
-        mock_webrick.expects(:mount).with("/", Puppet::Network::HTTP::WEBrickREST, anything)
+        expect(mock_webrick).to receive(:mount).with("/", Puppet::Network::HTTP::WEBrickREST)
 
         server.listen(address, port)
       end
@@ -117,7 +114,7 @@ describe Puppet::Network::HTTP::WEBrick do
     end
 
     it "should order webrick server to stop" do
-      mock_webrick.expects(:shutdown)
+      expect(mock_webrick).to receive(:shutdown)
       server.listen(address, port)
       server.unlisten
     end
@@ -133,14 +130,14 @@ describe Puppet::Network::HTTP::WEBrick do
     let(:server) { Puppet::Network::HTTP::WEBrick.new }
 
     before :each do
-      Puppet.settings.stubs(:use)
-      @filehandle = stub 'handle', :fcntl => nil, :sync= => nil
+      allow(Puppet.settings).to receive(:use)
+      @filehandle = double('handle', :fcntl => nil, :sync= => nil)
 
-      File.stubs(:open).returns @filehandle
+      allow(File).to receive(:open).and_return(@filehandle)
     end
 
     it "should use the settings for :main, :ssl, and :application" do
-      Puppet.settings.expects(:use).with(:main, :ssl, :application)
+      expect(Puppet.settings).to receive(:use).with(:main, :ssl, :application)
 
       server.setup_logger
     end
@@ -149,7 +146,7 @@ describe Puppet::Network::HTTP::WEBrick do
       log = make_absolute("/master/log")
       Puppet[:masterhttplog] = log
 
-      File.expects(:open).with(log, "a+:UTF-8").returns @filehandle
+      expect(File).to receive(:open).with(log, "a+:UTF-8").and_return(@filehandle)
 
       server.setup_logger
     end
@@ -157,45 +154,45 @@ describe Puppet::Network::HTTP::WEBrick do
     describe "and creating the logging filehandle" do
       it "should set the close-on-exec flag if supported" do
         if defined? Fcntl::FD_CLOEXEC
-          @filehandle.expects(:fcntl).with(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+          expect(@filehandle).to receive(:fcntl).with(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
         else
-          @filehandle.expects(:fcntl).never
+          expect(@filehandle).not_to receive(:fcntl)
         end
 
         server.setup_logger
       end
 
       it "should sync the filehandle" do
-        @filehandle.expects(:sync=).with(true)
+        expect(@filehandle).to receive(:sync=).with(true)
 
         server.setup_logger
       end
     end
 
     it "should create a new WEBrick::Log instance with the open filehandle" do
-      WEBrick::Log.expects(:new).with(@filehandle)
+      expect(WEBrick::Log).to receive(:new).with(@filehandle)
 
       server.setup_logger
     end
 
     it "should set debugging if the current loglevel is :debug" do
-      Puppet::Util::Log.expects(:level).returns :debug
+      expect(Puppet::Util::Log).to receive(:level).and_return(:debug)
 
-      WEBrick::Log.expects(:new).with { |handle, debug| debug == WEBrick::Log::DEBUG }
+      expect(WEBrick::Log).to receive(:new).with(anything, WEBrick::Log::DEBUG)
 
       server.setup_logger
     end
 
     it "should return the logger as the main log" do
-      logger = mock 'logger'
-      WEBrick::Log.expects(:new).returns logger
+      logger = double('logger')
+      expect(WEBrick::Log).to receive(:new).and_return(logger)
 
       expect(server.setup_logger[:Logger]).to eq(logger)
     end
 
     it "should return the logger as the access log using both the Common and Referer log format" do
-      logger = mock 'logger'
-      WEBrick::Log.expects(:new).returns logger
+      logger = double('logger')
+      expect(WEBrick::Log).to receive(:new).and_return(logger)
 
       expect(server.setup_logger[:AccessLog]).to eq([
         [logger, WEBrick::AccessLog::COMMON_LOG_FORMAT],
@@ -206,8 +203,8 @@ describe Puppet::Network::HTTP::WEBrick do
 
   describe "when configuring ssl" do
     it "should use the key from the localhost SSL::Host instance" do
-      Puppet::SSL::Host.expects(:localhost).returns host
-      host.expects(:key).returns key
+      expect(Puppet::SSL::Host).to receive(:localhost).and_return(host)
+      expect(host).to receive(:key).and_return(key)
 
       expect(server.setup_ssl[:SSLPrivateKey]).to eq("mykey")
     end
@@ -217,7 +214,7 @@ describe Puppet::Network::HTTP::WEBrick do
     end
 
     it "should fail if no CA certificate can be found" do
-      Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns nil
+      allow(Puppet::SSL::Certificate.indirection).to receive(:find).with('ca').and_return(nil)
 
       expect { server.setup_ssl }.to raise_error(Puppet::Error, /Could not find CA certificate/)
     end
@@ -262,7 +259,7 @@ describe Puppet::Network::HTTP::WEBrick do
     end
 
     it "should add an x509 store" do
-      host.expects(:ssl_store).returns "mystore"
+      expect(host).to receive(:ssl_store).and_return("mystore")
 
       expect(server.setup_ssl[:SSLCertificateStore]).to eq("mystore")
     end
@@ -272,7 +269,7 @@ describe Puppet::Network::HTTP::WEBrick do
     end
 
     it "specifies the allowable ciphers" do
-      mock_ssl_context.expects(:ciphers=).with(server.class::CIPHERS)
+      expect(mock_ssl_context).to receive(:ciphers=).with(server.class::CIPHERS)
 
       server.create_server('localhost', '8888')
     end