puppet 6.0.7-x64-mingw32 → 6.0.8-x64-mingw32

data/spec/unit/network/authconfig_spec.rb

@@ -1,27 +1,26 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/authconfig'
 
 describe Puppet::Network::DefaultAuthProvider do
   before :each do
-    Puppet::FileSystem.stubs(:stat).returns stub('stat', :ctime => :now)
-    Time.stubs(:now).returns Time.now
+    allow(Puppet::FileSystem).to receive(:stat).and_return(double('stat', :ctime => :now))
+    allow(Time).to receive(:now).and_return(Time.now)
 
-    Puppet::Network::DefaultAuthProvider.any_instance.stubs(:exists?).returns(true)
+    allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:exists?).and_return(true)
     # FIXME @authprovider = Puppet::Network::DefaultAuthProvider.new("dummy")
   end
 
   describe "when initializing" do
     it "inserts default ACLs after setting initial rights" do
-      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
+      expect_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl)
       Puppet::Network::DefaultAuthProvider.new
     end
   end
 
   describe "when defining an acl with mk_acl" do
     before :each do
-      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
+      allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl)
       @authprovider = Puppet::Network::DefaultAuthProvider.new
     end
 
@@ -53,26 +52,26 @@ describe Puppet::Network::DefaultAuthProvider do
 
   describe "when adding default ACLs" do
     before :each do
-      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
+      allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl)
       @authprovider = Puppet::Network::DefaultAuthProvider.new
-      Puppet::Network::DefaultAuthProvider.any_instance.unstub(:insert_default_acl)
+      allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl).and_call_original
     end
 
     Puppet::Network::DefaultAuthProvider::default_acl.each do |acl|
       it "should create a default right for #{acl[:acl]}" do
-        @authprovider.stubs(:mk_acl)
-        @authprovider.expects(:mk_acl).with(acl)
+        allow(@authprovider).to receive(:mk_acl)
+        expect(@authprovider).to receive(:mk_acl).with(acl)
         @authprovider.insert_default_acl
       end
     end
 
     it "should log at info loglevel" do
-      Puppet.expects(:info).at_least_once
+      expect(Puppet).to receive(:info).at_least(:once)
       @authprovider.insert_default_acl
     end
 
     it "creates an empty catch-all rule for '/' for any authentication request state" do
-      @authprovider.stubs(:mk_acl)
+      allow(@authprovider).to receive(:mk_acl)
 
       @authprovider.insert_default_acl
       expect(@authprovider.rights['/']).to be_empty
@@ -86,8 +85,8 @@ describe Puppet::Network::DefaultAuthProvider do
         :allow => '$1',
         :authenticated => true
       }
-      @authprovider.stubs(:mk_acl)
-      @authprovider.expects(:mk_acl).with(acl)
+      allow(@authprovider).to receive(:mk_acl)
+      expect(@authprovider).to receive(:mk_acl).with(acl)
       @authprovider.insert_default_acl
     end
   end
@@ -101,7 +100,7 @@ describe Puppet::Network::DefaultAuthProvider do
         :authenticated => true
       }
 
-      Puppet::Network::Rights.any_instance.expects(:is_request_forbidden_and_why?).with(:save, "/path/to/resource", params)
+      expect_any_instance_of(Puppet::Network::Rights).to receive(:is_request_forbidden_and_why?).with(:save, "/path/to/resource", params)
 
       described_class.new.check_authorization(:save, "/path/to/resource", params)
     end
@@ -121,19 +120,19 @@ describe Puppet::Network::AuthConfig do
   it "instantiates authprovider_class with rights" do
     Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
     rights = Puppet::Network::Rights.new
-    TestAuthProvider.expects(:new).with(rights)
+    expect(TestAuthProvider).to receive(:new).with(rights)
     described_class.new(rights)
   end
 
   it "delegates authorization check to authprovider_class" do
     Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
-    TestAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
+    expect_any_instance_of(TestAuthProvider).to receive(:check_authorization).with(:save, '/path/to/resource', {})
     described_class.new.check_authorization(:save, '/path/to/resource', {})
   end
 
   it "uses DefaultAuthProvider by default" do
     Puppet::Network::AuthConfig.authprovider_class = nil
-    Puppet::Network::DefaultAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
+    expect_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:check_authorization).with(:save, '/path/to/resource', {})
     described_class.new.check_authorization(:save, '/path/to/resource', {})
   end
 end

data/spec/unit/network/authorization_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet/network/http/api/indirected_routes'
@@ -27,8 +26,8 @@ describe Puppet::Network::Authorization do
     end
 
     it "creates default ACL entries if no file has been read" do
-      Puppet::Network::AuthConfigParser.expects(:new_from_file).raises Errno::ENOENT
-      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
+      expect(Puppet::Network::AuthConfigParser).to receive(:new_from_file).and_raise(Errno::ENOENT)
+      expect_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl)
 
       subject.authconfig
     end
@@ -52,8 +51,8 @@ describe Puppet::Network::Authorization do
     it "delegates to the authconfig object" do
       Puppet::Network::Authorization.authconfigloader_class =
           TestAuthConfigLoader
-      TestAuthConfig.any_instance.expects(:check_authorization).with(
-          :save, '/mypath', {:param1 => "value1"}).returns("yay, it worked!")
+      expect_any_instance_of(TestAuthConfig).to receive(:check_authorization).with(
+          :save, '/mypath', {:param1 => "value1"}).and_return("yay, it worked!")
       expect(subject.check_authorization(
                  :save, '/mypath',
                  {:param1 => "value1"})).to eq("yay, it worked!")

data/spec/unit/network/authstore_spec.rb

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

data/spec/unit/network/format_handler_spec.rb

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

data/spec/unit/network/format_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/format'
@@ -76,7 +75,7 @@ describe Puppet::Network::Format do
     it "should consider a class supported if the provided class has all required methods present" do
       format = Puppet::Network::Format.new(:foo)
       [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
-        format.expects(:required_method_present?).with { |name, klass, type| name == method and klass == String }.returns true
+        expect(format).to receive(:required_method_present?).with(method, String, anything).and_return(true)
       end
 
       expect(format).to be_required_methods_present(String)
@@ -84,8 +83,8 @@ describe Puppet::Network::Format do
 
     it "should consider a class not supported if any required methods are missing from the provided class" do
       format = Puppet::Network::Format.new(:foo)
-      format.stubs(:required_method_present?).returns true
-      format.expects(:required_method_present?).with { |name, *args| name == :intern_method }.returns false
+      allow(format).to receive(:required_method_present?).and_return(true)
+      expect(format).to receive(:required_method_present?).with(:intern_method, anything, anything).and_return(false)
       expect(format).not_to be_required_methods_present(String)
     end
 
@@ -95,13 +94,13 @@ describe Puppet::Network::Format do
 
     it "should only test for required methods if specific methods are specified as required" do
       format = Puppet::Network::Format.new(:foo, :required_methods => [:intern_method])
-      format.expects(:required_method_present?).with { |name, klass, type| name == :intern_method }
+      expect(format).to receive(:required_method_present?).with(:intern_method, anything, anything)
 
       format.required_methods_present?(String)
     end
 
     it "should not consider a class supported unless the format is suitable" do
-      @format.expects(:suitable?).returns false
+      expect(@format).to receive(:suitable?).and_return(false)
       expect(@format).not_to be_supported(FormatRenderer)
     end
 
@@ -168,22 +167,22 @@ describe Puppet::Network::Format do
     end
 
     it "should return the results of calling the instance-specific render method if the method is present" do
-      @instance.expects(:to_my_format).returns "foo"
+      expect(@instance).to receive(:to_my_format).and_return("foo")
       expect(@format.render(@instance)).to eq("foo")
     end
 
     it "should return the results of calling the class-specific render_multiple method if the method is present" do
-      @instance.class.expects(:to_multiple_my_format).returns ["foo"]
+      expect(@instance.class).to receive(:to_multiple_my_format).and_return(["foo"])
       expect(@format.render_multiple([@instance])).to eq(["foo"])
     end
 
     it "should return the results of calling the class-specific intern method if the method is present" do
-      FormatRenderer.expects(:from_my_format).with("foo").returns @instance
+      expect(FormatRenderer).to receive(:from_my_format).with("foo").and_return(@instance)
       expect(@format.intern(FormatRenderer, "foo")).to equal(@instance)
     end
 
     it "should return the results of calling the class-specific intern_multiple method if the method is present" do
-      FormatRenderer.expects(:from_multiple_my_format).with("foo").returns [@instance]
+      expect(FormatRenderer).to receive(:from_multiple_my_format).with("foo").and_return([@instance])
       expect(@format.intern_multiple(FormatRenderer, "foo")).to eq([@instance])
     end
 

data/spec/unit/network/format_support_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/format_handler'
@@ -21,13 +20,13 @@ describe Puppet::Network::FormatHandler do
   describe "when listing formats" do
     before(:each) do
       one = Puppet::Network::FormatHandler.create(:one, :weight => 1)
-      one.stubs(:supported?).returns(true)
+      allow(one).to receive(:supported?).and_return(true)
       two = Puppet::Network::FormatHandler.create(:two, :weight => 6)
-      two.stubs(:supported?).returns(true)
+      allow(two).to receive(:supported?).and_return(true)
       three = Puppet::Network::FormatHandler.create(:three, :weight => 2)
-      three.stubs(:supported?).returns(true)
+      allow(three).to receive(:supported?).and_return(true)
       four = Puppet::Network::FormatHandler.create(:four, :weight => 8)
-      four.stubs(:supported?).returns(false)
+      allow(four).to receive(:supported?).and_return(false)
     end
 
     it "should return all supported formats in decreasing order of weight" do
@@ -36,16 +35,16 @@ describe Puppet::Network::FormatHandler do
   end
 
   it "should return the first format as the default format" do
-    FormatTester.expects(:supported_formats).returns [:one, :two]
+    expect(FormatTester).to receive(:supported_formats).and_return [:one, :two]
     expect(FormatTester.default_format).to eq(:one)
   end
 
   describe "with a preferred serialization format setting" do
     before do
       one = Puppet::Network::FormatHandler.create(:one, :weight => 1)
-      one.stubs(:supported?).returns(true)
+      allow(one).to receive(:supported?).and_return(true)
       two = Puppet::Network::FormatHandler.create(:two, :weight => 6)
-      two.stubs(:supported?).returns(true)
+      allow(two).to receive(:supported?).and_return(true)
     end
 
     describe "that is supported" do
@@ -68,8 +67,8 @@ describe Puppet::Network::FormatHandler do
       end
 
       it "should log a debug message" do
-        Puppet.expects(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
-        Puppet.expects(:debug).with("FormatTester supports formats: two one")
+        expect(Puppet).to receive(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
+        expect(Puppet).to receive(:debug).with("FormatTester supports formats: two one")
         FormatTester.supported_formats
       end
     end
@@ -79,27 +78,27 @@ describe Puppet::Network::FormatHandler do
     let(:format) { Puppet::Network::FormatHandler.create(:my_format, :mime => "text/myformat") }
 
     it "should use the Format to determine whether a given format is supported" do
-      format.expects(:supported?).with(FormatTester)
+      expect(format).to receive(:supported?).with(FormatTester)
       FormatTester.support_format?(:my_format)
     end
 
     it "should call the format-specific converter when asked to convert from a given format" do
-      format.expects(:intern).with(FormatTester, "mydata")
+      expect(format).to receive(:intern).with(FormatTester, "mydata")
       FormatTester.convert_from(:my_format, "mydata")
     end
 
     it "should call the format-specific converter when asked to convert from a given format by mime-type" do
-      format.expects(:intern).with(FormatTester, "mydata")
+      expect(format).to receive(:intern).with(FormatTester, "mydata")
       FormatTester.convert_from("text/myformat", "mydata")
     end
 
     it "should call the format-specific converter when asked to convert from a given format by format instance" do
-      format.expects(:intern).with(FormatTester, "mydata")
+      expect(format).to receive(:intern).with(FormatTester, "mydata")
       FormatTester.convert_from(format, "mydata")
     end
 
     it "should raise a FormatError when an exception is encountered when converting from a format" do
-      format.expects(:intern).with(FormatTester, "mydata").raises "foo"
+      expect(format).to receive(:intern).with(FormatTester, "mydata").and_raise("foo")
       expect do
         FormatTester.convert_from(:my_format, "mydata")
       end.to raise_error(
@@ -109,26 +108,26 @@ describe Puppet::Network::FormatHandler do
     end
 
     it "should be able to use a specific hook for converting into multiple instances" do
-      format.expects(:intern_multiple).with(FormatTester, "mydata")
+      expect(format).to receive(:intern_multiple).with(FormatTester, "mydata")
 
       FormatTester.convert_from_multiple(:my_format, "mydata")
     end
 
     it "should raise a FormatError when an exception is encountered when converting multiple items from a format" do
-      format.expects(:intern_multiple).with(FormatTester, "mydata").raises "foo"
+      expect(format).to receive(:intern_multiple).with(FormatTester, "mydata").and_raise("foo")
       expect do
         FormatTester.convert_from_multiple(:my_format, "mydata")
       end.to raise_error(Puppet::Network::FormatHandler::FormatError, 'Could not intern_multiple from my_format: foo')
     end
 
     it "should be able to use a specific hook for rendering multiple instances" do
-      format.expects(:render_multiple).with("mydata")
+      expect(format).to receive(:render_multiple).with("mydata")
 
       FormatTester.render_multiple(:my_format, "mydata")
     end
 
     it "should raise a FormatError when an exception is encountered when rendering multiple items into a format" do
-      format.expects(:render_multiple).with("mydata").raises "foo"
+      expect(format).to receive(:render_multiple).with("mydata").and_raise("foo")
       expect do
         FormatTester.render_multiple(:my_format, "mydata")
       end.to raise_error(Puppet::Network::FormatHandler::FormatError, 'Could not render_multiple to my_format: foo')
@@ -139,13 +138,13 @@ describe Puppet::Network::FormatHandler do
     let(:format) { Puppet::Network::FormatHandler.create(:foo, :mime => "text/foo") }
 
     it "should list as supported a format that reports itself supported" do
-      format.expects(:supported?).returns true
+      expect(format).to receive(:supported?).and_return(true)
       expect(FormatTester.new.support_format?(:foo)).to be_truthy
     end
 
     it "should raise a FormatError when a rendering error is encountered" do
       tester = FormatTester.new
-      format.expects(:render).with(tester).raises "eh"
+      expect(format).to receive(:render).with(tester).and_raise("eh")
 
       expect do
         tester.render(:foo)
@@ -154,45 +153,45 @@ describe Puppet::Network::FormatHandler do
 
     it "should call the format-specific converter when asked to convert to a given format" do
       tester = FormatTester.new
-      format.expects(:render).with(tester).returns "foo"
+      expect(format).to receive(:render).with(tester).and_return("foo")
 
       expect(tester.render(:foo)).to eq("foo")
     end
 
     it "should call the format-specific converter when asked to convert to a given format by mime-type" do
       tester = FormatTester.new
-      format.expects(:render).with(tester).returns "foo"
+      expect(format).to receive(:render).with(tester).and_return("foo")
 
       expect(tester.render("text/foo")).to eq("foo")
     end
 
     it "should call the format converter when asked to convert to a given format instance" do
       tester = FormatTester.new
-      format.expects(:render).with(tester).returns "foo"
+      expect(format).to receive(:render).with(tester).and_return("foo")
 
       expect(tester.render(format)).to eq("foo")
     end
 
     it "should render to the default format if no format is provided when rendering" do
-      FormatTester.expects(:default_format).returns :foo
+      expect(FormatTester).to receive(:default_format).and_return(:foo)
       tester = FormatTester.new
 
-      format.expects(:render).with(tester)
+      expect(format).to receive(:render).with(tester)
       tester.render
     end
 
     it "should call the format-specific converter when asked for the mime-type of a given format" do
       tester = FormatTester.new
-      format.expects(:mime).returns "text/foo"
+      expect(format).to receive(:mime).and_return("text/foo")
 
       expect(tester.mime(:foo)).to eq("text/foo")
     end
 
     it "should return the default format mime-type if no format is provided" do
-      FormatTester.expects(:default_format).returns :foo
+      expect(FormatTester).to receive(:default_format).and_return(:foo)
       tester = FormatTester.new
 
-      format.expects(:mime).returns "text/foo"
+      expect(format).to receive(:mime).and_return("text/foo")
       expect(tester.mime).to eq("text/foo")
     end
   end

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)