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

data/spec/unit/indirector/facts/network_device_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device'
@@ -24,11 +25,11 @@ end
 
 describe Puppet::Node::Facts::NetworkDevice do
   before :each do
-    @remote_device = double('remote_device', :facts => {})
-    allow(Puppet::Util::NetworkDevice).to receive(:current).and_return(@remote_device)
+    @remote_device = stub 'remote_device', :facts => {}
+    Puppet::Util::NetworkDevice.stubs(:current).returns(@remote_device)
     @device = Puppet::Node::Facts::NetworkDevice.new
     @name = "me"
-    @request = double('request', :key => @name)
+    @request = stub 'request', :key => @name
   end
 
   describe Puppet::Node::Facts::NetworkDevice, " when finding facts" do
@@ -41,23 +42,23 @@ describe Puppet::Node::Facts::NetworkDevice do
     end
 
     it "should return the device facts as the values in the Facts instance" do
-      expect(@remote_device).to receive(:facts).and_return("one" => "two")
+      @remote_device.expects(:facts).returns("one" => "two")
       facts = @device.find(@request)
       expect(facts.values["one"]).to eq("two")
     end
 
     it "should add local facts" do
       facts = Puppet::Node::Facts.new("foo")
-      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
-      expect(facts).to receive(:add_local_facts)
+      Puppet::Node::Facts.expects(:new).returns facts
+      facts.expects(:add_local_facts)
 
       @device.find(@request)
     end
 
     it "should sanitize facts" do
       facts = Puppet::Node::Facts.new("foo")
-      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
-      expect(facts).to receive(:sanitize)
+      Puppet::Node::Facts.expects(:new).returns facts
+      facts.expects(:sanitize)
 
       @device.find(@request)
     end

data/spec/unit/indirector/facts/rest_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/facts/rest'
@@ -11,29 +12,29 @@ describe Puppet::Node::Facts::Rest do
   before(:each) { model.indirection.terminus_class = :rest }
 
   def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = double('http response', :code => code.to_s, :body => body)
-    allow(obj).to receive(:[]).with('content-type').and_return(content_type)
-    allow(obj).to receive(:[]).with('content-encoding').and_return(encoding)
-    allow(obj).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
+    obj = stub('http response', :code => code.to_s, :body => body)
+    obj.stubs(:[]).with('content-type').returns(content_type)
+    obj.stubs(:[]).with('content-encoding').returns(encoding)
+    obj.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
     obj
   end
 
   describe '#save' do
     subject { model.indirection.terminus(:rest) }
 
-    let(:connection) { double('mock http connection', :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :verify_callback= => nil) }
     let(:node_name) { 'puppet.node.test' }
     let(:data) { model.new(node_name, {test_fact: 'test value'}) }
     let(:request) { Puppet::Indirector::Request.new(:facts, :save, node_name, data) }
 
     before :each do
-      allow(subject).to receive(:network).and_return(connection)
+      subject.stubs(:network).returns(connection)
     end
 
     context 'when a 404 response is received' do
       let(:response) { mock_response(404, '{}', 'test/json') }
 
-      before(:each) { expect(connection).to receive(:put).and_return(response) }
+      before(:each) { connection.expects(:put).returns response }
 
       it 'riases with HTTP 404' do
         expect{ subject.save(request) }.to raise_error(Net::HTTPError,

data/spec/unit/indirector/facts/store_configs_spec.rb

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

data/spec/unit/indirector/facts/yaml_spec.rb

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

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/file'
@@ -54,7 +55,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         checksum_value = save_bucket_file(first_contents, "/foo/bar")
 
         # We expect Puppet to log an error with the path to the file
-        expect(Puppet).to receive(:err).with(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/)
+        Puppet.expects(:err).with(regexp_matches(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/))
 
         # But the exception should not contain it
         expect do
@@ -79,7 +80,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         end
 
         it "issues a warning that the backup will be overwritten" do
-          expect(Puppet).to receive(:warning).with(/Existing backup does not match its expected sum, #{bucket_file.checksum}/)
+          Puppet.expects(:warning).with(regexp_matches(/Existing backup does not match its expected sum, #{bucket_file.checksum}/))
           Puppet::FileBucket::File.indirection.save(bucket_file)
         end
 
@@ -340,7 +341,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         describe "when #{supply_path ? 'supplying' : 'not supplying'} a path" do
           with_digest_algorithms do
             before :each do
-              allow(Puppet.settings).to receive(:use)
+              Puppet.settings.stubs(:use)
               @store = Puppet::FileBucketFile::File.new
 
               @bucket_top_dir = tmpdir("bucket")

data/spec/unit/indirector/file_bucket_file/rest_spec.rb

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

data/spec/unit/indirector/file_bucket_file/selector_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/selector'
@@ -8,17 +9,17 @@ describe Puppet::FileBucketFile::Selector do
   %w[head find save search destroy].each do |method|
     describe "##{method}" do
       it "should proxy to rest terminus for https requests" do
-        request = double('request', :protocol => 'https')
+        request = stub 'request', :protocol => 'https'
 
-        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(method).with(request)
+        Puppet::FileBucketFile::Rest.any_instance.expects(method).with(request)
 
         subject.send(method, request)
       end
 
       it "should proxy to file terminus for other requests" do
-        request = double('request', :protocol => 'file')
+        request = stub 'request', :protocol => 'file'
 
-        expect_any_instance_of(Puppet::FileBucketFile::File).to receive(method).with(request)
+        Puppet::FileBucketFile::File.any_instance.expects(method).with(request)
 
         subject.send(method, request)
       end

data/spec/unit/indirector/file_content/file_server_spec.rb

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

data/spec/unit/indirector/file_content/file_spec.rb

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

data/spec/unit/indirector/file_content/rest_spec.rb

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

data/spec/unit/indirector/file_content/selector_spec.rb

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

data/spec/unit/indirector/file_metadata/file_server_spec.rb

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

data/spec/unit/indirector/file_metadata/file_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_metadata/file'
@@ -16,17 +17,17 @@ describe Puppet::Indirector::FileMetadata::File do
       @metadata = Puppet::Indirector::FileMetadata::File.new
       @path = File.expand_path('/my/local')
       @uri = Puppet::Util.path_to_uri(@path).to_s
-      @data = double('metadata')
-      allow(@data).to receive(:collect)
-      expect(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
+      @data = mock 'metadata'
+      @data.stubs(:collect)
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
 
       @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri, nil)
     end
 
     it "should collect its attributes when a file is found" do
-      expect(@data).to receive(:collect)
+      @data.expects(:collect)
 
-      expect(Puppet::FileServing::Metadata).to receive(:new).and_return(@data)
+      Puppet::FileServing::Metadata.expects(:new).returns(@data)
       expect(@metadata.find(@request)).to eq(@data)
     end
   end
@@ -41,15 +42,15 @@ describe Puppet::Indirector::FileMetadata::File do
     end
 
     it "should collect the attributes of the instances returned" do
-      expect(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-      expect(Puppet::FileServing::Fileset).to receive(:new).with(@path, @request).and_return(double("fileset"))
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return([["one", @path], ["two", @path]])
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
+      Puppet::FileServing::Fileset.expects(:new).with(@path, @request).returns mock("fileset")
+      Puppet::FileServing::Fileset.expects(:merge).returns [["one", @path], ["two", @path]]
 
-      one = double("one", :collect => nil)
-      expect(Puppet::FileServing::Metadata).to receive(:new).with(@path, {:relative_path => "one"}).and_return(one)
+      one = mock("one", :collect => nil)
+      Puppet::FileServing::Metadata.expects(:new).with(@path, {:relative_path => "one"}).returns one
 
-      two = double("two", :collect => nil)
-      expect(Puppet::FileServing::Metadata).to receive(:new).with(@path, {:relative_path => "two"}).and_return(two)
+      two = mock("two", :collect => nil)
+      Puppet::FileServing::Metadata.expects(:new).with(@path, {:relative_path => "two"}).returns two
 
       expect(@metadata.search(@request)).to eq([one, two])
     end

data/spec/unit/indirector/file_metadata/rest_spec.rb

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

data/spec/unit/indirector/file_metadata/selector_spec.rb

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

data/spec/unit/indirector/file_server_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_server'
@@ -26,7 +27,7 @@ describe Puppet::Indirector::FileServer do
   let(:indirection) { Puppet::FileTestModel.indirection }
   let(:model) { Puppet::FileTestModel }
   let(:uri) { "puppet://host/my/local/file" }
-  let(:configuration) { double('configuration') }
+  let(:configuration) { mock 'configuration' }
 
   after(:all) do
     Puppet::FileTestModel.indirection.delete
@@ -34,159 +35,158 @@ describe Puppet::Indirector::FileServer do
   end
 
   before(:each)do
-    allow(Puppet::FileServing::Configuration).to receive(:configuration).and_return(configuration)
+    Puppet::FileServing::Configuration.stubs(:configuration).returns(configuration)
   end
 
   describe "when finding files" do
-    let(:mount) { double('mount', find: nil) }
-    let(:instance) { double('instance', :links= => nil, :collect => nil) }
+    let(:mount) { stub('mount', find: nil) }
+    let(:instance) { stub('instance', :links= => nil, :collect => nil) }
 
     it "should use the configuration to find the mount and relative path" do
-      expect(configuration).to receive(:split_path) do |args|
-        expect(args.uri).to eq(uri)
-        nil
+      configuration.expects(:split_path).with do |args|
+        args.uri == uri
       end
 
       indirection.find(uri)
     end
 
     it "should return nil if it cannot find the mount" do
-      expect(configuration).to receive(:split_path).and_return([nil, nil])
+      configuration.expects(:split_path).returns(nil, nil)
 
       expect(indirection.find(uri)).to be_nil
     end
 
     it "should use the mount to find the full path" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:find).with("rel/path", anything)
+      mount.expects(:find).with { |key, request| key == "rel/path" }
 
       indirection.find(uri)
     end
 
     it "should pass the request when finding a file" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:find) { |_, request| expect(request.uri).to eq(uri) }.and_return(nil)
+      mount.expects(:find).with { |_, request| request.uri == uri }
 
       indirection.find(uri)
     end
 
     it "should return nil if it cannot find a full path" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:find).with("rel/path", anything)
+      mount.expects(:find).with { |key, request| key == "rel/path" }.returns nil
 
       expect(indirection.find(uri)).to be_nil
     end
 
     it "should create an instance with the found path" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
+      mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
-      expect(model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(instance)
+      model.expects(:new).with("/my/file", {:relative_path => nil}).returns instance
 
       expect(indirection.find(uri)).to equal(instance)
     end
 
     it "should set 'links' on the instance if it is set in the request options" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
+      mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
-      expect(model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(instance)
+      model.expects(:new).with("/my/file", {:relative_path => nil}).returns instance
 
-      expect(instance).to receive(:links=).with(true)
+      instance.expects(:links=).with(true)
 
       expect(indirection.find(uri, links: true)).to equal(instance)
     end
 
     it "should collect the instance" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
+      mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
-      expect(model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(instance)
+      model.expects(:new).with("/my/file", {:relative_path => nil}).returns instance
 
-      expect(instance).to receive(:collect)
+      instance.expects(:collect)
 
       expect(indirection.find(uri, links: true)).to equal(instance)
     end
   end
 
   describe "when searching for instances" do
-    let(:mount) { double('mount', find: nil) }
+    let(:mount) { stub('mount', find: nil) }
 
     it "should use the configuration to search the mount and relative path" do
-      expect(configuration).to receive(:split_path) do |args|
-        expect(args.uri).to eq(uri)
-      end.and_return([nil, nil])
+      configuration.expects(:split_path).with do |args|
+        args.uri == uri
+      end
 
       indirection.search(uri)
     end
 
     it "should return nil if it cannot search the mount" do
-      expect(configuration).to receive(:split_path).and_return([nil, nil])
+      configuration.expects(:split_path).returns(nil, nil)
 
       expect(indirection.search(uri)).to be_nil
     end
 
     it "should use the mount to search for the full paths" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:search).with("rel/path", anything)
+      mount.expects(:search).with { |key, request| key == "rel/path" }
 
       indirection.search(uri)
     end
 
     it "should pass the request" do
-      allow(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.stubs(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:search) { |_, request| expect(request.uri).to eq(uri) }.and_return(nil)
+      mount.expects(:search).with { |_, request| request.uri == uri }
 
       indirection.search(uri)
     end
 
     it "should return nil if searching does not find any full paths" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:search).with("rel/path", anything).and_return(nil)
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns nil
 
       expect(indirection.search(uri)).to be_nil
     end
 
     it "should create a fileset with each returned path and merge them" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:search).with("rel/path", anything).and_return(%w{/one /two})
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns %w{/one /two}
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      one = double('fileset_one')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with("/one", anything).and_return(one)
-      two = double('fileset_two')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with("/two", anything).and_return(two)
+      one = mock 'fileset_one'
+      Puppet::FileServing::Fileset.expects(:new).with("/one", anything).returns(one)
+      two = mock 'fileset_two'
+      Puppet::FileServing::Fileset.expects(:new).with("/two", anything).returns(two)
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).with(one, two).and_return([])
+      Puppet::FileServing::Fileset.expects(:merge).with(one, two).returns []
 
       indirection.search(uri)
     end
 
     it "should create an instance with each path resulting from the merger of the filesets" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:search).with("rel/path", anything).and_return([])
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one", "two" => "/two")
+      Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one", "two" => "/two")
 
-      one = double('one', :collect => nil)
-      expect(model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
+      one = stub 'one', :collect => nil
+      model.expects(:new).with("/one", :relative_path => "one").returns one
 
-      two = double('two', :collect => nil)
-      expect(model).to receive(:new).with("/two", :relative_path => "two").and_return(two)
+      two = stub 'two', :collect => nil
+      model.expects(:new).with("/two", :relative_path => "two").returns two
 
       # order can't be guaranteed
       result = indirection.search(uri)
@@ -196,67 +196,67 @@ describe Puppet::Indirector::FileServer do
     end
 
     it "should set 'links' on the instances if it is set in the request options" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:search).with("rel/path", anything).and_return([])
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
+      Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
-      one = double('one', :collect => nil)
-      expect(model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
-      expect(one).to receive(:links=).with(true)
+      one = stub 'one', :collect => nil
+      model.expects(:new).with("/one", :relative_path => "one").returns one
+      one.expects(:links=).with true
 
       indirection.search(uri, links: true)
     end
 
     it "should set 'checksum_type' on the instances if it is set in the request options" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:search).with("rel/path", anything).and_return([])
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
+      Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
-      one = double('one', :collect => nil)
-      expect(model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
+      one = stub 'one', :collect => nil
+      model.expects(:new).with("/one", :relative_path => "one").returns one
 
-      expect(one).to receive(:checksum_type=).with(:checksum)
+      one.expects(:checksum_type=).with :checksum
 
       indirection.search(uri, checksum_type: :checksum)
     end
 
     it "should collect the instances" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(mount).to receive(:search).with("rel/path", anything).and_return([])
+      mount.expects(:search).with { |key, options| key == "rel/path" }.returns []
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
+      Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
-      one = double('one')
-      expect(model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
-      expect(one).to receive(:collect)
+      one = mock 'one'
+      model.expects(:new).with("/one", :relative_path => "one").returns one
+      one.expects(:collect)
 
       indirection.search(uri)
     end
   end
 
   describe "when checking authorization" do
-    let(:mount) { double('mount', :empty? => nil, :globalallow? => nil) }
+    let(:mount) { stub('mount') }
     let(:request) { Puppet::Indirector::Request.new(:myind, :mymethod, uri, :environment => "myenv") }
 
     before(:each) do
       request.method = :find
 
-      allow(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-      allow(request).to receive(:node).and_return("mynode")
-      allow(request).to receive(:ip).and_return("myip")
-      allow(mount).to receive(:name).and_return("myname")
-      allow(mount).to receive(:allowed?).with("mynode", "myip").and_return("something")
+      configuration.stubs(:split_path).returns([mount, "rel/path"])
+      request.stubs(:node).returns("mynode")
+      request.stubs(:ip).returns("myip")
+      mount.stubs(:name).returns "myname"
+      mount.stubs(:allowed?).with("mynode", "myip").returns "something"
     end
 
     it "should return false when destroying" do
@@ -270,32 +270,32 @@ describe Puppet::Indirector::FileServer do
     end
 
     it "should use the configuration to find the mount and relative path" do
-      expect(configuration).to receive(:split_path).with(request)
+      configuration.expects(:split_path).with(request)
 
       terminus.authorized?(request)
     end
 
     it "should return false if it cannot find the mount" do
-      expect(configuration).to receive(:split_path).and_return([nil, nil])
+      configuration.expects(:split_path).returns(nil, nil)
 
       expect(terminus).not_to be_authorized(request)
     end
 
     it "should return true when no auth directives are defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(true)
-      allow(mount).to receive(:globalallow?).and_return(nil)
+      mount.stubs(:empty?).returns true
+      mount.stubs(:globalallow?).returns nil
       expect(terminus).to be_authorized(request)
     end
 
     it "should return true when a global allow directive is defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(false)
-      allow(mount).to receive(:globalallow?).and_return(true)
+      mount.stubs(:empty?).returns false
+      mount.stubs(:globalallow?).returns true
       expect(terminus).to be_authorized(request)
     end
 
     it "should return false when a non-global allow directive is defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(false)
-      allow(mount).to receive(:globalallow?).and_return(false)
+      mount.stubs(:empty?).returns false
+      mount.stubs(:globalallow?).returns false
       expect(terminus).not_to be_authorized(request)
     end
   end