puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/file_serving/content_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/content'
@@ -24,7 +25,7 @@ describe Puppet::FileServing::Content do
   it "should not retrieve and store its contents when its attributes are collected" do
     content = Puppet::FileServing::Content.new(path)
 
-    expect(File).not_to receive(:read).with(path)
+    File.expects(:read).with(path).never
     content.collect
 
     expect(content.instance_variable_get("@content")).to be_nil
@@ -46,10 +47,10 @@ describe Puppet::FileServing::Content do
   end
 
   it "should create an instance with a fake file name and correct content when converting from binary" do
-    instance = double('instance')
-    expect(Puppet::FileServing::Content).to receive(:new).with("/this/is/a/fake/path").and_return(instance)
+    instance = mock 'instance'
+    Puppet::FileServing::Content.expects(:new).with("/this/is/a/fake/path").returns instance
 
-    expect(instance).to receive(:content=).with("foo/bar")
+    instance.expects(:content=).with "foo/bar"
 
     expect(Puppet::FileServing::Content.from_binary("foo/bar")).to equal(instance)
   end
@@ -57,7 +58,7 @@ describe Puppet::FileServing::Content do
   it "should return an opened File when converted to binary" do
     content = Puppet::FileServing::Content.new(path)
 
-    expect(File).to receive(:new).with(path, "rb").and_return(:file)
+    File.expects(:new).with(path, "rb").returns :file
 
     expect(content.to_binary).to eq(:file)
   end
@@ -69,7 +70,7 @@ describe Puppet::FileServing::Content, "when returning the contents" do
 
   it "should fail if the file is a symlink and links are set to :manage" do
     content.links = :manage
-    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double("stat", :ftype => "symlink"))
+    Puppet::FileSystem.expects(:lstat).with(path).returns stub("stat", :ftype => "symlink")
     expect { content.content }.to raise_error(ArgumentError)
   end
 
@@ -83,14 +84,14 @@ describe Puppet::FileServing::Content, "when returning the contents" do
   end
 
   it "should return the contents of the path if the file exists" do
-    expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(double('stat', :ftype => 'file'))
-    expect(Puppet::FileSystem).to receive(:binread).with(path).and_return(:mycontent)
+    Puppet::FileSystem.expects(:stat).with(path).returns(stub('stat', :ftype => 'file'))
+    Puppet::FileSystem.expects(:binread).with(path).returns(:mycontent)
     expect(content.content).to eq(:mycontent)
   end
 
   it "should cache the returned contents" do
-    expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(double('stat', :ftype => 'file'))
-    expect(Puppet::FileSystem).to receive(:binread).with(path).and_return(:mycontent)
+    Puppet::FileSystem.expects(:stat).with(path).returns(stub('stat', :ftype => 'file'))
+    Puppet::FileSystem.expects(:binread).with(path).returns(:mycontent)
     content.content
     # The second run would throw a failure if the content weren't being cached.
     content.content

data/spec/unit/file_serving/fileset_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/fileset'
@@ -17,49 +18,49 @@ describe Puppet::FileServing::Fileset do
 
     it "removes a trailing file path separator" do
       path_with_separator = "#{somefile}#{File::SEPARATOR}"
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       fileset = Puppet::FileServing::Fileset.new(path_with_separator)
       expect(fileset.path).to eq(somefile)
     end
 
     it "can be created from the root directory" do
       path = File.expand_path(File::SEPARATOR)
-      expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(path).returns stub('stat')
       fileset = Puppet::FileServing::Fileset.new(path)
       expect(fileset.path).to eq(path)
     end
 
     it "fails if its path does not exist" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_raise(Errno::ENOENT)
+      Puppet::FileSystem.expects(:lstat).with(somefile).raises(Errno::ENOENT)
       expect { Puppet::FileServing::Fileset.new(somefile) }.to raise_error(ArgumentError, "Fileset paths must exist")
     end
 
     it "accepts a 'recurse' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :recurse => true)
       expect(set.recurse).to be_truthy
     end
 
     it "accepts a 'recurselimit' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :recurselimit => 3)
       expect(set.recurselimit).to eq(3)
     end
 
     it "accepts an 'ignore' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :ignore => ".svn")
       expect(set.ignore).to eq([".svn"])
     end
 
     it "accepts a 'links' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :links => :manage)
       expect(set.links).to eq(:manage)
     end
 
     it "accepts a 'checksum_type' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :checksum_type => :test)
       expect(set.checksum_type).to eq(:test)
     end
@@ -69,22 +70,22 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "defaults to 'false' for recurse" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       expect(Puppet::FileServing::Fileset.new(somefile).recurse).to eq(false)
     end
 
     it "defaults to :infinite for recurselimit" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       expect(Puppet::FileServing::Fileset.new(somefile).recurselimit).to eq(:infinite)
     end
 
     it "defaults to an empty ignore list" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       expect(Puppet::FileServing::Fileset.new(somefile).ignore).to eq([])
     end
 
     it "defaults to :manage for links" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       expect(Puppet::FileServing::Fileset.new(somefile).links).to eq(:manage)
     end
 
@@ -92,7 +93,7 @@ describe Puppet::FileServing::Fileset do
       let(:values) { { :links => :manage, :ignore => %w{a b}, :recurse => true, :recurselimit => 1234 } }
 
       before :each do
-        expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+        Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       end
 
       [:recurse, :recurselimit, :ignore, :links].each do |option|
@@ -129,16 +130,16 @@ describe Puppet::FileServing::Fileset do
   context "when recursing" do
     before do
       @path = make_absolute("/my/path")
-      allow(Puppet::FileSystem).to receive(:lstat).with(@path).and_return(double('stat', :directory? => true))
+      Puppet::FileSystem.stubs(:lstat).with(@path).returns stub('stat', :directory? => true)
 
       @fileset = Puppet::FileServing::Fileset.new(@path)
 
-      @dirstat = double('dirstat', :directory? => true)
-      @filestat = double('filestat', :directory? => false)
+      @dirstat = stub 'dirstat', :directory? => true
+      @filestat = stub 'filestat', :directory? => false
     end
 
     def mock_dir_structure(path, stat_method = :lstat)
-      allow(Puppet::FileSystem).to receive(stat_method).with(path).and_return(@dirstat)
+      Puppet::FileSystem.stubs(stat_method).with(path).returns @dirstat
 
       # Keep track of the files we're stubbing.
       @files = %w{.}
@@ -146,59 +147,53 @@ describe Puppet::FileServing::Fileset do
       top_names = %w{one two .svn CVS}
       sub_names = %w{file1 file2 .svn CVS 0 false}
 
-      allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(top_names)
+      Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(top_names)
       top_names.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
-        allow(Puppet::FileSystem).to receive(stat_method).with(subpath).and_return(@dirstat)
-        allow(Dir).to receive(:entries).with(subpath, encoding: Encoding::UTF_8).and_return(sub_names)
+        Puppet::FileSystem.stubs(stat_method).with(subpath).returns @dirstat
+        Dir.stubs(:entries).with(subpath, encoding: Encoding::UTF_8).returns(sub_names)
         sub_names.each do |file|
           @files << File.join(subdir, file) # relative path
           subfile_path = File.join(subpath, file)
-          allow(Puppet::FileSystem).to receive(stat_method).with(subfile_path).and_return(@filestat)
+          Puppet::FileSystem.stubs(stat_method).with(subfile_path).returns(@filestat)
         end
       end
     end
 
-    def setup_mocks_for_dir(mock_dir, base_path)
-      path = File.join(base_path, mock_dir.name)
-      allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(MockStat.new(path, true))
-      allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(['.', '..'] + mock_dir.entries.map(&:name))
-      mock_dir.entries.each do |entry|
-        setup_mocks_for_entry(entry, path)
+    MockStat = Struct.new(:path, :directory) do
+      # struct doesn't support thing ending in ?
+      def directory?
+        directory
       end
     end
 
-    def setup_mocks_for_file(mock_file, base_path)
-      path = File.join(base_path, mock_file.name)
-      allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(MockStat.new(path, false))
-    end
-
-    def setup_mocks_for_entry(entry, base_path)
-      case entry
-      when MockDirectory
-        setup_mocks_for_dir(entry, base_path)
-      when MockFile
-        setup_mocks_for_file(entry, base_path)
+    MockDirectory = Struct.new(:name, :entries) do
+      def mock(base_path)
+        extend Mocha::API
+        path = File.join(base_path, name)
+        Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, true)
+        Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(['.', '..'] + entries.map(&:name))
+        entries.each do |entry|
+          entry.mock(path)
+        end
       end
     end
 
-    MockStat = Struct.new(:path, :directory) do
-      # struct doesn't support thing ending in ?
-      def directory?
-        directory
+    MockFile = Struct.new(:name) do
+      def mock(base_path)
+        extend Mocha::API
+        path = File.join(base_path, name)
+        Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, false)
       end
     end
 
-    MockDirectory = Struct.new(:name, :entries)
-    MockFile = Struct.new(:name)
-
     it "doesn't ignore pending directories when the last entry at the top level is a file" do
       structure = MockDirectory.new('path',
                     [MockDirectory.new('dir1',
                                    [MockDirectory.new('a', [MockFile.new('f')])]),
                      MockFile.new('file')])
-      setup_mocks_for_dir(structure, make_absolute('/your'))
+      structure.mock(make_absolute('/your'))
       fileset = Puppet::FileServing::Fileset.new(make_absolute('/your/path'))
       fileset.recurse = true
       fileset.links = :manage
@@ -281,8 +276,8 @@ describe Puppet::FileServing::Fileset do
 
     it "works when paths have regexp significant characters" do
       @path = make_absolute("/my/path/rV1x2DafFr0R6tGG+1bbk++++TM")
-      stat = double('dir_stat', :directory? => true)
-      expect(Puppet::FileSystem).to receive(:lstat).with(@path).and_return(double(@path, :stat => stat, :lstat => stat))
+      stat = stub('dir_stat', :directory? => true)
+      Puppet::FileSystem.expects(:lstat).with(@path).returns stub(@path, :stat => stat, :lstat => stat)
       @fileset = Puppet::FileServing::Fileset.new(@path)
       mock_dir_structure(@path)
       @fileset.recurse = true
@@ -292,15 +287,15 @@ describe Puppet::FileServing::Fileset do
 
   it "manages the links to missing files" do
     path = make_absolute("/my/path")
-    stat = double('stat', :directory? => true)
+    stat = stub 'stat', :directory? => true
 
-    expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(stat)
-    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
+    Puppet::FileSystem.expects(:stat).with(path).returns stat
+    Puppet::FileSystem.expects(:lstat).with(path).returns stat
 
     link_path = File.join(path, "mylink")
-    expect(Puppet::FileSystem).to receive(:stat).with(link_path).and_raise(Errno::ENOENT)
+    Puppet::FileSystem.expects(:stat).with(link_path).raises(Errno::ENOENT)
 
-    allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(["mylink"])
+    Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(["mylink"])
 
     fileset = Puppet::FileServing::Fileset.new(path)
 
@@ -313,20 +308,20 @@ describe Puppet::FileServing::Fileset do
   context "when merging other filesets" do
     before do
       @paths = [make_absolute("/first/path"), make_absolute("/second/path"), make_absolute("/third/path")]
-      allow(Puppet::FileSystem).to receive(:lstat).and_return(double('stat', :directory? => false))
+      Puppet::FileSystem.stubs(:lstat).returns stub('stat', :directory? => false)
 
       @filesets = @paths.collect do |path|
-        allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double('stat', :directory? => true))
+        Puppet::FileSystem.stubs(:lstat).with(path).returns stub('stat', :directory? => true)
         Puppet::FileServing::Fileset.new(path, :recurse => true)
       end
 
-      allow(Dir).to receive(:entries).and_return([])
+      Dir.stubs(:entries).returns []
     end
 
     it "returns a hash of all files in each fileset with the value being the base path" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one uno})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{two dos})
-      expect(Dir).to receive(:entries).with(make_absolute("/third/path"), encoding: Encoding::UTF_8).and_return(%w{three tres})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one uno})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{two dos})
+      Dir.expects(:entries).with(make_absolute("/third/path"), encoding: Encoding::UTF_8).returns(%w{three tres})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)).to eq({
         "." => make_absolute("/first/path"),
@@ -340,15 +335,15 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "includes the base directory from the first fileset" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{two})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{two})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["."]).to eq(make_absolute("/first/path"))
     end
 
     it "uses the base path of the first found file when relative file paths conflict" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{one})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{one})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["one"]).to eq(make_absolute("/first/path"))
     end

data/spec/unit/file_serving/http_metadata_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/http_metadata'
 require 'matchers/json'
@@ -31,8 +32,8 @@ describe Puppet::FileServing::HttpMetadata do
 
     context "with no Last-Modified or Content-MD5 header from the server" do
       before do
-        allow(http_response).to receive(:[]).with('last-modified').and_return(nil)
-        allow(http_response).to receive(:[]).with('content-md5').and_return(nil)
+        http_response.stubs(:[]).with('last-modified').returns nil
+        http_response.stubs(:[]).with('content-md5').returns nil
       end
 
       it "should use :mtime as the checksum type, based on current time" do
@@ -50,14 +51,13 @@ describe Puppet::FileServing::HttpMetadata do
 
     context "with a Last-Modified header from the server" do
       let(:time) { Time.now.utc }
-
       before do
-        allow(http_response).to receive(:[]).with('content-md5').and_return(nil)
+        http_response.stubs(:[]).with('content-md5').returns nil
       end
 
       it "should use :mtime as the checksum type, based on Last-Modified" do
         # HTTP uses "GMT" not "UTC"
-        allow(http_response).to receive(:[]).with('last-modified').and_return(time.strftime("%a, %d %b %Y %T GMT"))
+        http_response.stubs(:[]).with('last-modified').returns(time.strftime("%a, %d %b %Y %T GMT"))
         metadata = described_class.new(http_response)
         metadata.collect
         expect( metadata.checksum_type ).to eq :mtime
@@ -69,10 +69,9 @@ describe Puppet::FileServing::HttpMetadata do
       let(:input) { Time.now.to_s }
       let(:base64) { Digest::MD5.new.base64digest input }
       let(:hex) { Digest::MD5.new.hexdigest input }
-
       before do
-        allow(http_response).to receive(:[]).with('last-modified').and_return(nil)
-        allow(http_response).to receive(:[]).with('content-md5').and_return(base64)
+        http_response.stubs(:[]).with('last-modified').returns nil
+        http_response.stubs(:[]).with('content-md5').returns base64
       end
 
       it "should use the md5 checksum" do

data/spec/unit/file_serving/metadata_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/metadata'
 require 'matchers/json'
@@ -183,14 +184,14 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
           it "should give a mtime checksum when checksum_type is set" do
             metadata.checksum_type = "mtime"
-            expect(metadata).to receive(:mtime_file).and_return(time)
+            metadata.expects(:mtime_file).returns(time)
             metadata.collect
             expect(metadata.checksum).to eq("{mtime}#{time}")
           end
 
           it "should give a ctime checksum when checksum_type is set" do
             metadata.checksum_type = "ctime"
-            expect(metadata).to receive(:ctime_file).and_return(time)
+            metadata.expects(:ctime_file).returns(time)
             metadata.collect
             expect(metadata.checksum).to eq("{ctime}#{time}")
           end
@@ -217,7 +218,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
         let(:time) { Time.now }
 
         before :each do
-          expect(metadata).to receive(:ctime_file).and_return(time)
+          metadata.expects(:ctime_file).returns(time)
         end
 
         it "should only use checksums of type 'ctime' for directories" do
@@ -227,7 +228,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
         it "should only use checksums of type 'ctime' for directories even if checksum_type set" do
           metadata.checksum_type = "mtime"
-          expect(metadata).not_to receive(:mtime_file)
+          metadata.expects(:mtime_file).never
           metadata.collect
           expect(metadata.checksum).to eq("{ctime}#{time}")
         end
@@ -248,9 +249,9 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       path = tmpfile('foo')
       FileUtils.touch(path)
 
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path).and_raise(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_owner).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_group).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_mode).with(path).raises(invalid_error)
 
       stat = Puppet::FileSystem.stat(path)
 
@@ -266,9 +267,9 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       path = tmpfile('bar')
       FileUtils.touch(path)
 
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path, :use).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path, :use).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path, :use).and_raise(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_owner).with(path, :use).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_group).with(path, :use).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_mode).with(path, :use).raises(invalid_error)
 
       stat = Puppet::FileSystem.stat(path)
 
@@ -347,8 +348,8 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
     let(:group) {20}
 
     before :each do
-      allow_any_instance_of(File::Stat).to receive(:uid).and_return(owner)
-      allow_any_instance_of(File::Stat).to receive(:gid).and_return(group)
+      File::Stat.any_instance.stubs(:uid).returns owner
+      File::Stat.any_instance.stubs(:gid).returns group
     end
 
     describe "when collecting attributes when managing files" do
@@ -393,8 +394,8 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
     before :each do
       require 'puppet/util/windows/security'
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).and_return(owner)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).and_return(group)
+      Puppet::Util::Windows::Security.stubs(:get_owner).returns owner
+      Puppet::Util::Windows::Security.stubs(:get_group).returns group
     end
 
     describe "when collecting attributes when managing files" do
@@ -440,19 +441,19 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       end
 
       it "should default owner" do
-        allow(Puppet::Util::Windows::Security).to receive(:get_owner).and_return(nil)
+        Puppet::Util::Windows::Security.stubs(:get_owner).returns nil
 
         expect(metadata.owner).to eq('S-1-5-32-544')
       end
 
       it "should default group" do
-        allow(Puppet::Util::Windows::Security).to receive(:get_group).and_return(nil)
+        Puppet::Util::Windows::Security.stubs(:get_group).returns nil
 
         expect(metadata.group).to eq('S-1-0-0')
       end
 
       it "should default mode" do
-        allow(Puppet::Util::Windows::Security).to receive(:get_mode).and_return(nil)
+        Puppet::Util::Windows::Security.stubs(:get_mode).returns nil
 
         expect(metadata.mode).to eq(0644)
       end
@@ -460,23 +461,24 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       describe "when the path raises an Invalid ACL error" do
         # these simulate the behavior of a symlink file whose target does not support ACLs
         it "should default owner" do
-          allow(Puppet::Util::Windows::Security).to receive(:get_owner).and_raise(invalid_dacl_error)
+          Puppet::Util::Windows::Security.stubs(:get_owner).raises(invalid_dacl_error)
 
           expect(metadata.owner).to eq('S-1-5-32-544')
         end
 
         it "should default group" do
-          allow(Puppet::Util::Windows::Security).to receive(:get_group).and_raise(invalid_dacl_error)
+          Puppet::Util::Windows::Security.stubs(:get_group).raises(invalid_dacl_error)
 
           expect(metadata.group).to eq('S-1-0-0')
         end
 
         it "should default mode" do
-          allow(Puppet::Util::Windows::Security).to receive(:get_mode).and_raise(invalid_dacl_error)
+          Puppet::Util::Windows::Security.stubs(:get_mode).raises(invalid_dacl_error)
 
           expect(metadata.mode).to eq(0644)
         end
       end
+
     end
 
     def set_mode(mode, path)
@@ -485,35 +487,35 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
   end
 end
 
+
 describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppet.features.manages_symlinks?, :uses_checksums => true do
   with_digest_algorithms do
     describe "when links are managed" do
       before do
         path = "/base/path/my/file"
         @file = Puppet::FileServing::Metadata.new(path, :links => :manage)
-        stat = double("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
-        expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
-        expect(Puppet::FileSystem).to receive(:readlink).with(path).and_return("/some/other/path")
-        allow(@file).to receive("#{digest_algorithm}_file".intern).and_return(checksum) # Remove these when :managed links are no longer checksumed.
+        stat = stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
+        Puppet::FileSystem.expects(:lstat).with(path).at_least_once.returns stat
+        Puppet::FileSystem.expects(:readlink).with(path).at_least_once.returns "/some/other/path"
+        @file.stubs("#{digest_algorithm}_file".intern).returns(checksum) # Remove these when :managed links are no longer checksumed.
 
         if Puppet::Util::Platform.windows?
-          win_stat = double('win_stat', :owner => 'snarf', :group => 'thundercats',
+          win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
             :ftype => 'link', :mode => 0755)
-          allow(Puppet::FileServing::Metadata::WindowsStat).to receive(:new).and_return(win_stat)
+          Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
         end
+
       end
 
       it "should store the destination of the link in :destination if links are :manage" do
         @file.collect
         expect(@file.destination).to eq("/some/other/path")
       end
-
       pending "should not collect the checksum if links are :manage" do
         # We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow.
         @file.collect
         expect(@file.checksum).to be_nil
       end
-
       it "should collect the checksum if links are :manage" do # see pending note above
         @file.collect
         expect(@file.checksum).to eq("{#{digest_algorithm}}#{checksum}")
@@ -524,24 +526,22 @@ describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppe
       before do
         path = "/base/path/my/file"
         @file = Puppet::FileServing::Metadata.new(path, :links => :follow)
-        stat = double("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
-        expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(stat)
-        expect(Puppet::FileSystem).not_to receive(:readlink)
+        stat = stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
+        Puppet::FileSystem.expects(:stat).with(path).at_least_once.returns stat
+        Puppet::FileSystem.expects(:readlink).never
 
         if Puppet::Util::Platform.windows?
-          win_stat = double('win_stat', :owner => 'snarf', :group => 'thundercats',
+          win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
             :ftype => 'file', :mode => 0755)
-          allow(Puppet::FileServing::Metadata::WindowsStat).to receive(:new).and_return(win_stat)
+          Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
         end
 
-        allow(@file).to receive("#{digest_algorithm}_file".intern).and_return(checksum)
+        @file.stubs("#{digest_algorithm}_file".intern).returns(checksum)
       end
-
       it "should not store the destination of the link in :destination if links are :follow" do
         @file.collect
         expect(@file.destination).to be_nil
       end
-
       it "should collect the checksum if links are :follow" do
         @file.collect
         expect(@file.checksum).to eq("{#{digest_algorithm}}#{checksum}")