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

data/spec/unit/face/status_spec.rb

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

data/spec/unit/file_bucket/dipper_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'pathname'
@@ -15,12 +16,7 @@ shared_examples_for "a restorable file" do
       it "should restore the file" do
         request = nil
 
-        # With the *_any_instance_of form of using a block on receive, the
-        # first argument to the block is which instance is currently being
-        # dealt with, and the remaining arguments are the arguments to the
-        # method, instead of the block only getting the arguments to the
-        # method.
-        expect_any_instance_of(klass).to receive(:find) { |_,r| request = r }.and_return(Puppet::FileBucket::File.new(plaintext))
+        klass.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(plaintext))
 
         expect(dipper.restore(dest, checksum)).to eq(checksum)
         expect(digest(Puppet::FileSystem.binread(dest))).to eq(checksum)
@@ -33,12 +29,12 @@ shared_examples_for "a restorable file" do
       it "should skip restoring if existing file has the same checksum" do
         File.open(dest, 'wb') {|f| f.print(plaintext) }
 
-        expect(dipper).not_to receive(:getfile)
+        dipper.expects(:getfile).never
         expect(dipper.restore(dest, checksum)).to be_nil
       end
 
       it "should overwrite existing file if it has different checksum" do
-        expect_any_instance_of(klass).to receive(:find).and_return(Puppet::FileBucket::File.new(plaintext))
+        klass.any_instance.expects(:find).returns(Puppet::FileBucket::File.new(plaintext))
 
         File.open(dest, 'wb') {|f| f.print('other contents') }
 
@@ -61,7 +57,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => make_absolute("/my/bucket"))
 
     file = make_tmp_file('contents')
-    expect(Puppet::FileBucket::File.indirection).to receive(:head).and_raise(ArgumentError)
+    Puppet::FileBucket::File.indirection.expects(:head).raises ArgumentError
 
     expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
@@ -70,8 +66,8 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => make_absolute("/my/bucket"))
 
     file = make_tmp_file('contents')
-    expect(Puppet::FileBucket::File.indirection).to receive(:head).and_return(false)
-    expect(Puppet::FileBucket::File.indirection).to receive(:save).and_raise(ArgumentError)
+    Puppet::FileBucket::File.indirection.expects(:head).returns false
+    Puppet::FileBucket::File.indirection.expects(:save).raises ArgumentError
 
     expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
@@ -122,9 +118,9 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
           expect(@dipper.diff(checksum2, nil, nil, file1)).to include(diff21)
           expect(@dipper.diff(nil, checksum1, file2, nil)).to include(diff21)
           expect(@dipper.diff(nil, nil, file2, file1)).to include(diff21)
+
         end
       end
-
       describe "in windows environment", :if => Puppet::Util::Platform.windows? do
         it "should fail in an informative way when trying to diff" do
           @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
@@ -139,10 +135,9 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
       end
     end
   end
-
   it "should fail in an informative way when there are failures listing files on the server" do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => "/unexistent/bucket")
-    expect(Puppet::FileBucket::File.indirection).to receive(:find).and_return(nil)
+    Puppet::FileBucket::File.indirection.expects(:find).returns nil
 
     expect { @dipper.list(nil, nil) }.to raise_error(Puppet::Error)
   end
@@ -261,7 +256,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
           @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
           wrong_checksum = "DEADBEEF"
 
-          expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:find).and_return(nil)
+          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns(nil)
           expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(Puppet::Error, "Failed to diff files")
 
         end
@@ -269,7 +264,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
         it "should properly diff files on the filebucket" do
           @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
 
-          expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:find).and_return("Probably valid diff")
+          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns("Probably valid diff")
 
           expect(@dipper.diff("checksum1", "checksum2", nil, nil)).to eq("Probably valid diff")
         end
@@ -321,10 +316,10 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         file = make_tmp_file(plaintext)
 
-        expect(Puppet::FileBucket::File.indirection).to receive(:head).with(
-          %r{#{digest_algorithm}/#{checksum}}, :bucket_path => "/my/bucket"
-        ).and_return(true)
-        expect(Puppet::FileBucket::File.indirection).not_to receive(:save)
+        Puppet::FileBucket::File.indirection.expects(:head).with(
+          regexp_matches(%r{#{digest_algorithm}/#{checksum}}), :bucket_path => "/my/bucket"
+        ).returns true
+        Puppet::FileBucket::File.indirection.expects(:save).never
         expect(@dipper.backup(file)).to eq(checksum)
       end
 
@@ -333,7 +328,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         request = nil
 
-        expect_any_instance_of(Puppet::FileBucketFile::File).to receive(:find) { |_,r| request = r }.once.and_return(Puppet::FileBucket::File.new(plaintext))
+        Puppet::FileBucketFile::File.any_instance.expects(:find).with{ |r| request = r }.once.returns(Puppet::FileBucket::File.new(plaintext))
 
         expect(@dipper.getfile(checksum)).to eq(plaintext)
 
@@ -354,8 +349,8 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
         request1 = nil
         request2 = nil
 
-        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:head) { |_,r| request1 = r }.once.and_return(nil)
-        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:save) { |_,r| request2 = r }.once
+        Puppet::FileBucketFile::Rest.any_instance.expects(:head).with { |r| request1 = r }.once.returns(nil)
+        Puppet::FileBucketFile::Rest.any_instance.expects(:save).with { |r| request2 = r }.once
 
         expect(@dipper.backup(file)).to eq(checksum)
         [request1, request2].each do |r|
@@ -370,7 +365,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         request = nil
 
-        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:find) { |_,r| request = r }.and_return(Puppet::FileBucket::File.new(plaintext))
+        Puppet::FileBucketFile::Rest.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(plaintext))
 
         expect(@dipper.getfile(checksum)).to eq(plaintext)
 
@@ -382,6 +377,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
   end
 
   describe "#restore" do
+
     describe "when restoring from a remote server" do
       let(:klass) { Puppet::FileBucketFile::Rest }
       let(:server) { "puppetmaster" }

data/spec/unit/file_bucket/file_spec.rb

@@ -1,6 +1,8 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_bucket/file'
 
+
 describe Puppet::FileBucket::File, :uses_checksums => true do
   include PuppetSpec::Files
 

data/spec/unit/file_serving/base_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/base'
@@ -41,7 +42,7 @@ describe Puppet::FileServing::Base do
   end
 
   it "should allow specification of a relative path" do
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
     expect(Puppet::FileServing::Base.new(path, :relative_path => "my/file").relative_path).to eq("my/file")
   end
 
@@ -50,19 +51,19 @@ describe Puppet::FileServing::Base do
   end
 
   it "should correctly indicate if the file is present" do
-    expect(Puppet::FileSystem).to receive(:lstat).with(file).and_return(double('stat'))
+    Puppet::FileSystem.expects(:lstat).with(file).returns stub('stat')
     expect(Puppet::FileServing::Base.new(file).exist?).to be_truthy
   end
 
   it "should correctly indicate if the file is absent" do
-    expect(Puppet::FileSystem).to receive(:lstat).with(file).and_raise(RuntimeError)
+    Puppet::FileSystem.expects(:lstat).with(file).raises RuntimeError
     expect(Puppet::FileServing::Base.new(file).exist?).to be_falsey
   end
 
   describe "when setting the relative path" do
     it "should require that the relative path be unqualified" do
       @file = Puppet::FileServing::Base.new(path)
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
       expect { @file.relative_path = File.expand_path("/qualified/file") }.to raise_error(ArgumentError)
     end
   end
@@ -101,7 +102,7 @@ describe Puppet::FileServing::Base do
     let(:file) { Puppet::FileServing::Base.new(path) }
 
     before :each do
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
+      Puppet::Util::Platform.stubs(:windows?).returns true
     end
 
     it "should preserve double slashes at the beginning of the path" do
@@ -118,26 +119,26 @@ describe Puppet::FileServing::Base do
   describe "when stat'ing files" do
     let(:path) { File.expand_path('/this/file') }
     let(:file) { Puppet::FileServing::Base.new(path) }
-    let(:stat) { double('stat', :ftype => 'file' ) }
-    let(:stubbed_file) { double(path, :stat => stat, :lstat => stat)}
+    let(:stat) { stub('stat', :ftype => 'file' ) }
+    let(:stubbed_file) { stub(path, :stat => stat, :lstat => stat)}
 
     it "should stat the file's full path" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
+      Puppet::FileSystem.expects(:lstat).with(path).returns stat
       file.stat
     end
 
     it "should fail if the file does not exist" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(path).and_raise(Errno::ENOENT)
+      Puppet::FileSystem.expects(:lstat).with(path).raises(Errno::ENOENT)
       expect { file.stat }.to raise_error(Errno::ENOENT)
     end
 
     it "should use :lstat if :links is set to :manage" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stubbed_file)
+      Puppet::FileSystem.expects(:lstat).with(path).returns stubbed_file
       file.stat
     end
 
     it "should use :stat if :links is set to :follow" do
-      expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(stubbed_file)
+      Puppet::FileSystem.expects(:stat).with(path).returns stubbed_file
       file.links = :follow
       file.stat
     end
@@ -149,14 +150,14 @@ describe Puppet::FileServing::Base do
     end
 
     it "should accept Windows paths on Windows" do
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
-      allow(Puppet.features).to receive(:posix?).and_return(false)
+      Puppet::Util::Platform.stubs(:windows?).returns true
+      Puppet.features.stubs(:posix?).returns(false)
 
       expect(Puppet::FileServing::Base).to be_absolute('c:/foo')
     end
 
     it "should reject Windows paths on POSIX" do
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      Puppet::Util::Platform.stubs(:windows?).returns false
 
       expect(Puppet::FileServing::Base).not_to be_absolute('c:/foo')
     end

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/configuration/parser'
@@ -33,10 +34,10 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should return a hash of the created mounts" do
-      mount1 = double('one', :validate => true)
-      mount2 = double('two', :validate => true)
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("two").and_return(mount2)
+      mount1 = mock 'one', :validate => true
+      mount2 = mock 'two', :validate => true
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+      Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
       write_config_file "[one]\n[two]\n"
 
       result = @parser.parse
@@ -55,21 +56,21 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should validate each created mount" do
-      mount1 = double('one')
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
+      mount1 = mock 'one'
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
       write_config_file "[one]\n"
 
-      expect(mount1).to receive(:validate)
+      mount1.expects(:validate)
 
       @parser.parse
     end
 
     it "should fail if any mount does not pass validation" do
-      mount1 = double('one')
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
+      mount1 = mock 'one'
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
       write_config_file "[one]\n"
 
-      expect(mount1).to receive(:validate).and_raise(RuntimeError)
+      mount1.expects(:validate).raises RuntimeError
 
       expect { @parser.parse }.to raise_error(RuntimeError)
     end
@@ -85,15 +86,15 @@ describe Puppet::FileServing::Configuration::Parser do
     include FSConfigurationParserTesting
 
     before do
-      @mount = double('testmount', :name => "one", :validate => true)
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(@mount)
-      allow(@parser).to receive(:add_modules_mount)
+      @mount = stub 'testmount', :name => "one", :validate => true
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(@mount)
+      @parser.stubs(:add_modules_mount)
     end
 
     it "should set the mount path to the path attribute from that section" do
       write_config_file "[one]\npath /some/path\n"
 
-      expect(@mount).to receive(:path=).with("/some/path")
+      @mount.expects(:path=).with("/some/path")
       @parser.parse
     end
 
@@ -101,16 +102,16 @@ describe Puppet::FileServing::Configuration::Parser do
       it "should support inline comments in #{acl_type}" do
         write_config_file "[one]\n#{acl_type} something \# will it work?\n"
 
-      expect(@mount).to receive(:info)
-      expect(@mount).to receive(acl_type).with("something")
+      @mount.expects(:info)
+      @mount.expects(acl_type).with("something")
       @parser.parse
       end
 
       it "should tell the mount to #{acl_type} from ACLs with varying spacing around commas" do
         write_config_file "[one]\n#{acl_type} someone,sometwo, somethree , somefour ,somefive\n"
 
-        expect(@mount).to receive(:info).exactly(5).times
-        expect(@mount).to receive(acl_type).exactly(5).times.with(eq('someone').or eq('sometwo').or eq('somethree').or eq('somefour').or eq('somefive'))
+        @mount.expects(:info).times(5)
+        @mount.expects(acl_type).times(5).with(any_of('someone','sometwo','somethree','somefour','somefive'))
         @parser.parse
       end
 
@@ -119,8 +120,8 @@ describe Puppet::FileServing::Configuration::Parser do
         it "should tell the mount to #{acl_type} from ACLs with glob at #{ip_pattern}" do
           write_config_file "[one]\n#{acl_type} #{ip_pattern}\n"
 
-          expect(@mount).to receive(:info)
-          expect(@mount).to receive(acl_type).with(ip_pattern)
+          @mount.expects(:info)
+          @mount.expects(acl_type).with(ip_pattern)
           @parser.parse
         end
       }
@@ -137,21 +138,21 @@ describe Puppet::FileServing::Configuration::Parser do
     include FSConfigurationParserTesting
 
     before do
-      @mount = double('modulesmount', :name => "modules", :validate => true)
+      @mount = stub 'modulesmount', :name => "modules", :validate => true
     end
 
     it "should create an instance of the Modules Mount class" do
       write_config_file "[modules]\n"
 
-      expect(Puppet::FileServing::Mount::Modules).to receive(:new).with("modules").and_return(@mount)
+      Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns @mount
       @parser.parse
     end
 
     it "should warn if a path is set" do
       write_config_file "[modules]\npath /some/path\n"
-      expect(Puppet::FileServing::Mount::Modules).to receive(:new).with("modules").and_return(@mount)
+      Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns(@mount)
 
-      expect(Puppet).to receive(:warning)
+      Puppet.expects(:warning)
       @parser.parse
     end
   end
@@ -160,20 +161,20 @@ describe Puppet::FileServing::Configuration::Parser do
     include FSConfigurationParserTesting
 
     before do
-      @mount = double('pluginsmount', :name => "plugins", :validate => true)
+      @mount = stub 'pluginsmount', :name => "plugins", :validate => true
     end
 
     it "should create an instance of the Plugins Mount class" do
       write_config_file "[plugins]\n"
 
-      expect(Puppet::FileServing::Mount::Plugins).to receive(:new).with("plugins").and_return(@mount)
+      Puppet::FileServing::Mount::Plugins.expects(:new).with("plugins").returns @mount
       @parser.parse
     end
 
     it "should warn if a path is set" do
       write_config_file "[plugins]\npath /some/path\n"
 
-      expect(Puppet).to receive(:warning)
+      Puppet.expects(:warning)
       @parser.parse
     end
   end

data/spec/unit/file_serving/configuration_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/configuration'
@@ -24,16 +25,17 @@ describe Puppet::FileServing::Configuration do
   end
 
   describe "when initializing" do
+
     it "should work without a configuration file" do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(false)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(false)
       expect { Puppet::FileServing::Configuration.configuration }.to_not raise_error
     end
 
     it "should parse the configuration file if present" do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-      @parser = double('parser')
-      expect(@parser).to receive(:parse).and_return({})
-      allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(true)
+      @parser = mock 'parser'
+      @parser.expects(:parse).returns({})
+      Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
       Puppet::FileServing::Configuration.configuration
     end
 
@@ -43,37 +45,38 @@ describe Puppet::FileServing::Configuration do
   end
 
   describe "when parsing the configuration file" do
+
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-      @parser = double('parser')
-      allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(true)
+      @parser = mock 'parser'
+      Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
     end
 
     it "should set the mount list to the results of parsing" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
+      @parser.expects(:parse).returns("one" => mock("mount"))
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("one")).to be_truthy
     end
 
     it "should not raise exceptions" do
-      expect(@parser).to receive(:parse).and_raise(ArgumentError)
+      @parser.expects(:parse).raises(ArgumentError)
       expect { Puppet::FileServing::Configuration.configuration }.to_not raise_error
     end
 
     it "should replace the existing mount list with the results of reparsing" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
+      @parser.expects(:parse).returns("one" => mock("mount"))
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("one")).to be_truthy
       # Now parse again
-      expect(@parser).to receive(:parse).and_return("two" => double('other'))
+      @parser.expects(:parse).returns("two" => mock('other'))
       config.send(:readconfig, false)
       expect(config.mounted?("one")).to be_falsey
       expect(config.mounted?("two")).to be_truthy
     end
 
     it "should not replace the mount list until the file is entirely parsed successfully" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
-      expect(@parser).to receive(:parse).and_raise(ArgumentError)
+      @parser.expects(:parse).returns("one" => mock("mount"))
+      @parser.expects(:parse).raises(ArgumentError)
       config = Puppet::FileServing::Configuration.configuration
       # Now parse again, so the exception gets thrown
       config.send(:readconfig, false)
@@ -81,7 +84,7 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should add modules, plugins, and tasks mounts even if the file does not exist" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("modules")).to be_truthy
       expect(config.mounted?("plugins")).to be_truthy
@@ -89,43 +92,43 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should allow all access to modules, plugins, and tasks if no fileserver.conf exists" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
-      modules = double('modules', :empty? => true)
-      allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      expect(modules).to receive(:allow).with('*')
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
+      modules = stub 'modules', :empty? => true
+      Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
+      modules.expects(:allow).with('*')
 
-      plugins = double('plugins', :empty? => true)
-      allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      expect(plugins).to receive(:allow).with('*')
+      plugins = stub 'plugins', :empty? => true
+      Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
+      plugins.expects(:allow).with('*')
 
-      tasks = double('tasks', :empty? => true)
-      allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      expect(tasks).to receive(:allow).with('*')
+      tasks = stub 'tasks', :empty? => true
+      Puppet::FileServing::Mount::Tasks.stubs(:new).returns(tasks)
+      tasks.expects(:allow).with('*')
 
       Puppet::FileServing::Configuration.configuration
     end
 
     it "should not allow access from all to modules, plugins, and tasks if the fileserver.conf provided some rules" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
 
-      modules = double('modules', :empty? => false)
-      allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      expect(modules).not_to receive(:allow).with('*')
+      modules = stub 'modules', :empty? => false
+      Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
+      modules.expects(:allow).with('*').never
 
-      plugins = double('plugins', :empty? => false)
-      allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      expect(plugins).not_to receive(:allow).with('*')
+      plugins = stub 'plugins', :empty? => false
+      Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
+      plugins.expects(:allow).with('*').never
 
-      tasks = double('tasks', :empty? => false)
-      allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      expect(tasks).not_to receive(:allow).with('*')
+      tasks = stub 'tasks', :empty? => false
+      Puppet::FileServing::Mount::Tasks.stubs(:new).returns(tasks)
+      tasks.expects(:allow).with('*').never
 
       Puppet::FileServing::Configuration.configuration
     end
 
     it "should add modules, plugins, and tasks mounts even if they are not returned by the parser" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(true) # the file doesn't exist
+      @parser.expects(:parse).returns("one" => mock("mount"))
+      Puppet::FileSystem.expects(:exist?).returns true # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("modules")).to be_truthy
       expect(config.mounted?("plugins")).to be_truthy
@@ -136,16 +139,16 @@ describe Puppet::FileServing::Configuration do
   describe "when finding the specified mount" do
     it "should choose the named mount if one exists" do
       config = Puppet::FileServing::Configuration.configuration
-      expect(config).to receive(:mounts).and_return("one" => "foo")
-      expect(config.find_mount("one", double('env'))).to eq("foo")
+      config.expects(:mounts).returns("one" => "foo")
+      expect(config.find_mount("one", mock('env'))).to eq("foo")
     end
 
     it "should return nil if there is no such named mount" do
       config = Puppet::FileServing::Configuration.configuration
 
-      env = double('environment')
-      mount = double('mount')
-      allow(config).to receive(:mounts).and_return("modules" => mount)
+      env = mock 'environment'
+      mount = mock 'mount'
+      config.stubs(:mounts).returns("modules" => mount)
 
       expect(config.find_mount("foo", env)).to be_nil
     end
@@ -153,66 +156,66 @@ describe Puppet::FileServing::Configuration do
 
   describe "#split_path" do
     let(:config) { Puppet::FileServing::Configuration.configuration }
-    let(:request) { double('request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => double("env")) }
+    let(:request) { stub 'request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => mock("env") }
 
     before do
-      allow(config).to receive(:find_mount)
+      config.stubs(:find_mount)
     end
 
     it "should reread the configuration" do
-      expect(config).to receive(:readconfig)
+      config.expects(:readconfig)
 
       config.split_path(request)
     end
 
     it "should treat the first field of the URI path as the mount name" do
-      expect(config).to receive(:find_mount).with("foo", anything)
+      config.expects(:find_mount).with { |name, node| name == "foo" }
 
       config.split_path(request)
     end
 
     it "should fail if the mount name is not alpha-numeric" do
-      expect(request).to receive(:key).and_return("foo&bar/asdf")
+      request.expects(:key).returns "foo&bar/asdf"
 
       expect { config.split_path(request) }.to raise_error(ArgumentError)
     end
 
     it "should support dashes in the mount name" do
-      expect(request).to receive(:key).and_return("foo-bar/asdf")
+      request.expects(:key).returns "foo-bar/asdf"
 
       expect { config.split_path(request) }.to_not raise_error
     end
 
     it "should use the mount name and environment to find the mount" do
-      expect(config).to receive(:find_mount).with("foo", request.environment)
-      allow(request).to receive(:node).and_return("mynode")
+      config.expects(:find_mount).with { |name, env| name == "foo" and env == request.environment }
+      request.stubs(:node).returns("mynode")
 
       config.split_path(request)
     end
 
     it "should return nil if the mount cannot be found" do
-      expect(config).to receive(:find_mount).and_return(nil)
+      config.expects(:find_mount).returns nil
 
       expect(config.split_path(request)).to be_nil
     end
 
     it "should return the mount and the relative path if the mount is found" do
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
+      mount = stub 'mount', :name => "foo"
+      config.expects(:find_mount).returns mount
 
       expect(config.split_path(request)).to eq([mount, "bar/baz"])
     end
 
     it "should remove any double slashes" do
-      allow(request).to receive(:key).and_return("foo/bar//baz")
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
+      request.stubs(:key).returns "foo/bar//baz"
+      mount = stub 'mount', :name => "foo"
+      config.expects(:find_mount).returns mount
 
       expect(config.split_path(request)).to eq([mount, "bar/baz"])
     end
 
     it "should fail if the path contains .." do
-      allow(request).to receive(:key).and_return('module/foo/../../bar')
+      request.stubs(:key).returns 'module/foo/../../bar'
 
       expect do
         config.split_path(request)
@@ -220,17 +223,17 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should return the relative path as nil if it is an empty string" do
-      expect(request).to receive(:key).and_return("foo")
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
+      request.expects(:key).returns "foo"
+      mount = stub 'mount', :name => "foo"
+      config.expects(:find_mount).returns mount
 
       expect(config.split_path(request)).to eq([mount, nil])
     end
 
     it "should add 'modules/' to the relative path if the modules mount is used but not specified, for backward compatibility" do
-      expect(request).to receive(:key).and_return("foo/bar")
-      mount = double('mount', :name => "modules")
-      expect(config).to receive(:find_mount).and_return(mount)
+      request.expects(:key).returns "foo/bar"
+      mount = stub 'mount', :name => "modules"
+      config.expects(:find_mount).returns mount
 
       expect(config.split_path(request)).to eq([mount, "foo/bar"])
     end