puppet 6.4.0-universal-darwin → 6.4.1-universal-darwin

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
@@ -6,13 +5,13 @@ require 'puppet/network/http/connection'
 
 describe Puppet::Network::HTTP::NoCachePool do
   let(:site) { Puppet::Network::HTTP::Site.new('https', 'rubygems.org', 443) }
-  let(:verifier) { stub('verifier', :setup_connection => nil) }
+  let(:verifier) { double('verifier', :setup_connection => nil) }
 
   it 'yields a started connection' do
-    http  = stub('http', start: nil, finish: nil)
+    http  = double('http', start: nil, finish: nil)
 
     factory = Puppet::Network::HTTP::Factory.new
-    factory.stubs(:create_connection).returns(http)
+    allow(factory).to receive(:create_connection).and_return(http)
     pool = Puppet::Network::HTTP::NoCachePool.new(factory)
 
     expect { |b|
@@ -21,11 +20,11 @@ describe Puppet::Network::HTTP::NoCachePool do
   end
 
   it 'yields a new connection each time' do
-    http1  = stub('http1', start: nil, finish: nil)
-    http2  = stub('http2', start: nil, finish: nil)
+    http1  = double('http1', start: nil, finish: nil)
+    http2  = double('http2', start: nil, finish: nil)
 
     factory = Puppet::Network::HTTP::Factory.new
-    factory.stubs(:create_connection).returns(http1).then.returns(http2)
+    allow(factory).to receive(:create_connection).and_return(http1, http2)
     pool = Puppet::Network::HTTP::NoCachePool.new(factory)
 
     expect { |b|

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'openssl'
@@ -22,7 +21,7 @@ describe Puppet::Network::HTTP::Pool do
   let(:ssl_context) { Puppet::SSL::SSLContext.new }
   let(:verifier) do
     v = Puppet::SSL::Verifier.new(site.host, ssl_context)
-    v.stubs(:setup_connection => nil)
+    allow(v).to receive(:setup_connection)
     v
   end
 
@@ -49,7 +48,7 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   def create_connection(site)
-    stub(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => true, :verify_mode => OpenSSL::SSL::VERIFY_PEER)
+    double(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => true, :verify_mode => OpenSSL::SSL::VERIFY_PEER)
   end
 
   context 'when yielding a connection' do
@@ -105,7 +104,7 @@ describe Puppet::Network::HTTP::Pool do
       pool = create_pool
       pool.release(site, verifier, conn)
 
-      pool.expects(:release).with(site, verifier, conn).never
+      expect(pool).not_to receive(:release).with(site, verifier, conn)
 
       pool.with_connection(site, verifier) do |c|
         raise IOError, 'connection reset'
@@ -140,33 +139,33 @@ describe Puppet::Network::HTTP::Pool do
     context 'when releasing connections' do
       it 'releases HTTP connections' do
         conn = create_connection(site)
-        conn.expects(:use_ssl?).returns(false)
+        expect(conn).to receive(:use_ssl?).and_return(false)
 
         pool = create_pool_with_connections(site, conn)
-        pool.expects(:release).with(site, verifier, conn)
+        expect(pool).to receive(:release).with(site, verifier, conn)
 
         pool.with_connection(site, verifier) {|c| }
       end
 
       it 'releases secure HTTPS connections' do
         conn = create_connection(site)
-        conn.expects(:use_ssl?).returns(true)
-        conn.expects(:verify_mode).returns(OpenSSL::SSL::VERIFY_PEER)
+        expect(conn).to receive(:use_ssl?).and_return(true)
+        expect(conn).to receive(:verify_mode).and_return(OpenSSL::SSL::VERIFY_PEER)
 
         pool = create_pool_with_connections(site, conn)
-        pool.expects(:release).with(site, verifier, conn)
+        expect(pool).to receive(:release).with(site, verifier, conn)
 
         pool.with_connection(site, verifier) {|c| }
       end
 
       it 'closes insecure HTTPS connections' do
         conn = create_connection(site)
-        conn.expects(:use_ssl?).returns(true)
-        conn.expects(:verify_mode).returns(OpenSSL::SSL::VERIFY_NONE)
+        expect(conn).to receive(:use_ssl?).and_return(true)
+        expect(conn).to receive(:verify_mode).and_return(OpenSSL::SSL::VERIFY_NONE)
 
         pool = create_pool_with_connections(site, conn)
 
-        pool.expects(:release).with(site, verifier, conn).never
+        expect(pool).not_to receive(:release).with(site, verifier, conn)
 
         pool.with_connection(site, verifier) {|c| }
       end
@@ -177,8 +176,8 @@ describe Puppet::Network::HTTP::Pool do
     it 'returns a new connection if the pool is empty' do
       conn = create_connection(site)
       pool = create_pool
-      pool.factory.expects(:create_connection).with(site).returns(conn)
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
+      expect(pool).to receive(:setsockopts)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
@@ -187,7 +186,7 @@ describe Puppet::Network::HTTP::Pool do
       conn = create_connection(site)
       pool = create_pool_with_connections(site, conn)
 
-      pool.factory.expects(:create_connection).never
+      expect(pool.factory).not_to receive(:create_connection)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
@@ -197,8 +196,8 @@ describe Puppet::Network::HTTP::Pool do
       pool = create_pool_with_connections(different_site, different_conn)
 
       conn = create_connection(site)
-      pool.factory.expects(:create_connection).with(site).returns(conn)
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
+      expect(pool).to receive(:setsockopts)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
@@ -206,13 +205,13 @@ describe Puppet::Network::HTTP::Pool do
     it 'returns a new connection if the ssl contexts are different' do
       old_conn = create_connection(site)
       pool = create_pool_with_connections(site, old_conn)
-      pool.stubs(:setsockopts)
+      allow(pool).to receive(:setsockopts)
 
       new_conn = create_connection(site)
-      pool.factory.stubs(:create_connection).with(site).returns(new_conn)
+      allow(pool.factory).to receive(:create_connection).with(site).and_return(new_conn)
 
       new_verifier = Puppet::SSL::Verifier.new(site.host, Puppet::SSL::SSLContext.new)
-      new_verifier.stubs(:setup_connection)
+      allow(new_verifier).to receive(:setup_connection)
 
       # 'equal' tests that it's the same object
       expect(pool.borrow(site, new_verifier)).to eq(new_conn)
@@ -221,9 +220,9 @@ describe Puppet::Network::HTTP::Pool do
     it 'returns a cached connection if the ssl contexts are the same' do
       old_conn = create_connection(site)
       pool = create_pool_with_connections(site, old_conn)
-      pool.stubs(:setsockopts)
+      allow(pool).to receive(:setsockopts)
 
-      pool.factory.expects(:create_connection).never
+      expect(pool.factory).not_to receive(:create_connection)
 
       # 'equal' tests that it's the same object
       new_verifier = Puppet::SSL::Verifier.new(site.host, ssl_context)
@@ -232,18 +231,18 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'returns started connections' do
       conn = create_connection(site)
-      conn.expects(:start)
+      expect(conn).to receive(:start)
 
       pool = create_pool
-      pool.factory.expects(:create_connection).with(site).returns(conn)
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
+      expect(pool).to receive(:setsockopts)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
 
     it "doesn't start a cached connection" do
       conn = create_connection(site)
-      conn.expects(:start).never
+      expect(conn).not_to receive(:start)
 
       pool = create_pool_with_connections(site, conn)
       pool.borrow(site, verifier)
@@ -259,24 +258,24 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'finishes expired connections' do
       conn = create_connection(site)
-      conn.expects(:finish)
+      expect(conn).to receive(:finish)
 
       pool = create_pool_with_expired_connections(site, conn)
-      pool.factory.expects(:create_connection => stub('conn', :start => nil))
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).and_return(double('conn', :start => nil))
+      expect(pool).to receive(:setsockopts)
 
       pool.borrow(site, verifier)
     end
 
     it 'logs an exception if it fails to close an expired connection' do
-      Puppet.expects(:log_exception).with(is_a(IOError), "Failed to close connection for #{site}: read timeout")
+      expect(Puppet).to receive(:log_exception).with(be_a(IOError), "Failed to close connection for #{site}: read timeout")
 
       conn = create_connection(site)
-      conn.expects(:finish).raises(IOError, 'read timeout')
+      expect(conn).to receive(:finish).and_raise(IOError, 'read timeout')
 
       pool = create_pool_with_expired_connections(site, conn)
-      pool.factory.expects(:create_connection => stub('open_conn', :start => nil))
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).and_return(double('open_conn', :start => nil))
+      expect(pool).to receive(:setsockopts)
 
       pool.borrow(site, verifier)
     end
@@ -320,7 +319,7 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'closes all cached connections' do
       conn = create_connection(site)
-      conn.expects(:finish)
+      expect(conn).to receive(:finish)
 
       pool = create_pool_with_connections(site, conn)
       pool.close

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,11 +1,10 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
 
 describe Puppet::Network::HTTP::Session do
-  let(:connection) { stub('connection') }
-  let(:verifier) { stub('verifier') }
+  let(:connection) { double('connection') }
+  let(:verifier) { double('verifier') }
 
   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_pool_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http_pool'
 
@@ -75,7 +74,7 @@ describe Puppet::Network::HttpPool do
       end
 
       it 'warns if an ssl_context is used for an http connection' do
-        Puppet.expects(:warning).with("An ssl_context is unnecessary when connecting to 'http://me:8140' and will be ignored")
+        expect(Puppet).to receive(:warning).with("An ssl_context is unnecessary when connecting to 'http://me:8140' and will be ignored")
 
         ssl_context = Puppet::SSL::SSLContext.new
         Puppet::Network::HttpPool.connection('me', 8140, use_ssl: false, ssl_context: ssl_context)
@@ -87,22 +86,22 @@ describe Puppet::Network::HttpPool do
         ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
 
         Puppet[:ssl_client_ca_auth] = ca_cert_file
-        Puppet::FileSystem.stubs(:exist?).with(ca_cert_file).returns(true)
+        allow(Puppet::FileSystem).to receive(:exist?).with(ca_cert_file).and_return(true)
       end
 
       def setup_standard_hostcert
         host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
-        Puppet::FileSystem.stubs(:exist?).with(host_cert_file).returns(true)
+        allow(Puppet::FileSystem).to receive(:exist?).with(host_cert_file).and_return(true)
 
         Puppet[:hostcert] = host_cert_file
       end
 
       def setup_standard_ssl_host
-        cert = stub('cert', :content => 'real_cert')
-        key  = stub('key',  :content => 'real_key')
-        host = stub('host', :certificate => cert, :key => key, :ssl_store => stub('store'))
+        cert = double('cert', :content => 'real_cert')
+        key  = double('key',  :content => 'real_key')
+        host = double('host', :certificate => cert, :key => key, :ssl_store => double('store'))
 
-        Puppet::SSL::Host.stubs(:localhost).returns(host)
+        allow(Puppet::SSL::Host).to receive(:localhost).and_return(host)
       end
 
       before do
@@ -114,14 +113,24 @@ describe Puppet::Network::HttpPool do
       it 'enables peer verification by default' do
         response = Net::HTTPOK.new('1.1', 200, 'body')
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true)
-        conn.expects(:execute_request).with { |http, request| expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER) }.returns(response)
+        expect(conn).to receive(:execute_request) do |http, _|
+          expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
+
+          response
+        end
+
         conn.get('/')
       end
 
       it 'can disable peer verification' do
         response = Net::HTTPOK.new('1.1', 200, 'body')
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true, false)
-        conn.expects(:execute_request).with { |http, request| expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE) }.returns(response)
+        expect(conn).to receive(:execute_request) do |http, _|
+          expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
+
+          response
+        end
+
         conn.get('/')
       end
     end

data/spec/unit/network/http_spec.rb

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

data/spec/unit/network/resolver_spec.rb

@@ -1,11 +1,10 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/resolver'
 
 describe Puppet::Network::Resolver do
   before do
-    @dns_mock_object = mock('dns')
-    Resolv::DNS.stubs(:new).returns(@dns_mock_object)
+    @dns_mock_object = double('dns')
+    allow(Resolv::DNS).to receive(:new).and_return(@dns_mock_object)
 
     @rr_type         = Resolv::DNS::Resource::IN::SRV
     @test_srv_domain = "domain.com"
@@ -31,7 +30,7 @@ describe Puppet::Network::Resolver do
 
   describe 'when the domain is not known' do
     before :each do
-      @dns_mock_object.stubs(:getresources).returns(@test_records)
+      allow(@dns_mock_object).to receive(:getresources).and_return(@test_records)
     end
 
     describe 'because domain is nil' do
@@ -55,10 +54,10 @@ describe Puppet::Network::Resolver do
 
     it "should not yield anything" do
       # No records returned for a DNS entry without any SRV records
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_a_hostname}",
         @rr_type
-      ).returns([])
+      ).and_return([])
 
       resolver.each_srv_record(@test_a_hostname) do |hostname, port, remaining|
         raise Exception.new("host with no records passed block")
@@ -76,10 +75,10 @@ describe Puppet::Network::Resolver do
         2 => ["puppet4.domain.com"]
       }
 
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(@test_records)
+      ).and_return(@test_records)
 
       resolver.each_srv_record(@test_srv_domain) do |hostname, port|
         expected_priority = order.keys.min
@@ -104,15 +103,15 @@ describe Puppet::Network::Resolver do
         2 => ["puppet4.domain.com"]
       }
 
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet-report._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns([])
+      ).and_return([])
 
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(@test_records)
+      ).and_return(@test_records)
 
       resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
@@ -145,15 +144,15 @@ describe Puppet::Network::Resolver do
         Resolv::DNS::Resource::IN::SRV.new(4,         1,      8140, "puppet4.bad.domain.com")
       ]
 
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet-report._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(@test_records)
+      ).and_return(@test_records)
 
-      @dns_mock_object.stubs(:getresources).with(
+      allow(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(bad_records)
+      ).and_return(bad_records)
 
       resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
@@ -200,7 +199,7 @@ describe Puppet::Network::Resolver do
         end
 
         total_weight.times do |n|
-          Kernel.expects(:rand).once.with(total_weight).returns(n)
+          expect(Kernel).to receive(:rand).once.with(total_weight).and_return(n)
           server = resolver.find_weighted_server(records)
           seen[server] += 1
         end
@@ -215,10 +214,10 @@ describe Puppet::Network::Resolver do
 
   describe "caching records" do
     it "should query DNS when no cache entry exists, then retrieve the cached value" do
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(@test_records).once
+      ).and_return(@test_records).once
 
       fetched_servers = []
       resolver.each_srv_record(@test_srv_domain) do |server, port|
@@ -226,7 +225,7 @@ describe Puppet::Network::Resolver do
       end
 
       cached_servers = []
-      resolver.expects(:expired?).returns false
+      expect(resolver).to receive(:expired?).and_return(false)
       resolver.each_srv_record(@test_srv_domain) do |server, port|
         cached_servers << server
       end
@@ -242,10 +241,10 @@ describe Puppet::Network::Resolver do
         ttl_record2.instance_variable_set(:@ttl, 20)
         records = [ttl_record1, ttl_record2]
 
-        @dns_mock_object.expects(:getresources).with(
+        expect(@dns_mock_object).to receive(:getresources).with(
           "_x-puppet._tcp.#{@test_srv_domain}",
           @rr_type
-        ).returns(records)
+        ).and_return(records)
       end
 
       it "should save the shortest TTL among records for a service" do
@@ -259,7 +258,7 @@ describe Puppet::Network::Resolver do
           expect(server).to match(/puppet.*domain\.com/)
         end
 
-        resolver.expects(:expired?).with(:puppet).returns false
+        expect(resolver).to receive(:expired?).with(:puppet).and_return(false)
         # Load from cache
         resolver.each_srv_record(@test_srv_domain) do |server, port|
           expect(server).to match(/puppet.*domain\.com/)
@@ -267,11 +266,11 @@ describe Puppet::Network::Resolver do
 
         new_record = Resolv::DNS::Resource::IN::SRV.new(0, 20, 8140, "new.domain.com")
         new_record.instance_variable_set(:@ttl, 10)
-        @dns_mock_object.expects(:getresources).with(
+        expect(@dns_mock_object).to receive(:getresources).with(
           "_x-puppet._tcp.#{@test_srv_domain}",
           @rr_type
-        ).returns([new_record])
-        resolver.expects(:expired?).with(:puppet).returns true
+        ).and_return([new_record])
+        expect(resolver).to receive(:expired?).with(:puppet).and_return(true)
         # Refresh from DNS
         resolver.each_srv_record(@test_srv_domain) do |server, port|
           expect(server).to eq("new.domain.com")