puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/face/parser_spec.rb

@@ -226,11 +226,11 @@ describe Puppet::Face[:parser, :current] do
   end
 
   def from_an_interactive_terminal
-    allow(STDIN).to receive(:tty?).and_return(true)
+    STDIN.stubs(:tty?).returns(true)
   end
 
   def from_a_piped_input_of(contents)
-    allow(STDIN).to receive(:tty?).and_return(false)
-    allow(STDIN).to receive(:read).and_return(contents)
+    STDIN.stubs(:tty?).returns(false)
+    STDIN.stubs(:read).returns(contents)
   end
 end

data/spec/unit/face/plugin_spec.rb

@@ -1,7 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
 describe Puppet::Face[:plugin, :current] do
+
   let(:pluginface) { described_class }
   let(:action) { pluginface.get_action(:download) }
 
@@ -16,48 +18,24 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, external facts, and locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       pluginface.download
-      expect(receive_count).to eq(3)
     end
 
     it "renders 'No plugins downloaded' if nothing was downloaded" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       result = pluginface.download
-      expect(receive_count).to eq(3)
       expect(render(result)).to eq('No plugins downloaded.')
     end
 
     it "renders comma separate list of downloaded file names" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        receive_count += 1
-        case receive_count
-        when 1
-          %w[/a]
-        when 2
-          %w[/b]
-        when 3
-          %w[/c]
-        end
-      end
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
 
       result = pluginface.download
-      expect(receive_count).to eq(3)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
     end
-
-    it "uses persistent HTTP pool" do
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        expect(Puppet.lookup(:http_pool)).to be_instance_of(Puppet::Network::HTTP::Pool)
-      end.and_return([])
-
-      pluginface.download
-    end
   end
 
   context "download when server_agent_version is 5.3.3" do
@@ -67,21 +45,15 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, and external facts, but not locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1}.and_return([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
 
       pluginface.download
     end
 
     it "renders comma separate list of downloaded file names that does not include locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        receive_count += 1
-        receive_count == 1 ? %w[/a] : %w[/b]
-      end
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
       result = pluginface.download
-      expect(receive_count).to eq(2)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')
     end
   end
@@ -94,22 +66,15 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, and external facts, but not locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
 
       pluginface.download
-      expect(receive_count).to eq(2)
     end
 
     it "renders comma separate list of downloaded file names that does not include locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        receive_count += 1
-        receive_count == 1 ? %w[/a] : %w[/b]
-      end
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
       result = pluginface.download
-      expect(receive_count).to eq(2)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')
     end
   end

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,14 +66,14 @@ 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
 
   describe "when diffing on a local filebucket" do
-    describe "in non-windows environments", :unless => Puppet.features.microsoft_windows? do
+    describe "in non-windows environments or JRuby", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
       with_digest_algorithms do
 
         it "should fail in an informative way when one or more checksum doesn't exists" do
@@ -122,10 +118,10 @@ 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.features.microsoft_windows? do
+      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"))
           wrong_checksum = "DEADBEEF"
@@ -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
@@ -255,13 +250,13 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
   end
 
   describe "when diffing on a remote filebucket" do
-    describe "in non-windows environments", :unless => Puppet.features.microsoft_windows? do
+    describe "in non-windows environments", :unless => Puppet::Util::Platform.windows? do
       with_digest_algorithms do
         it "should fail in an informative way when one or more checksum doesn't exists" 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,14 +264,14 @@ 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
       end
     end
 
-    describe "in windows environment", :if => Puppet.features.microsoft_windows? do
+    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(:Server => "puppetmaster", :Port => "31337")
         wrong_checksum = "DEADBEEF"
@@ -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'
@@ -40,13 +41,8 @@ describe Puppet::FileServing::Base do
     expect(Puppet::FileServing::Base.new(path).links).to eq(:manage)
   end
 
-  it "should allow specification of a path" do
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    expect(Puppet::FileServing::Base.new(path, :path => file).path).to eq(file)
-  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
 
@@ -55,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
@@ -105,13 +101,15 @@ describe Puppet::FileServing::Base do
     let(:path) { '//server/share/filename' }
     let(:file) { Puppet::FileServing::Base.new(path) }
 
+    before :each do
+      Puppet::Util::Platform.stubs(:windows?).returns true
+    end
+
     it "should preserve double slashes at the beginning of the path" do
-      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
       expect(file.full_path).to eq(path)
     end
 
     it "should strip double slashes not at the beginning of the path" do
-      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
       file = Puppet::FileServing::Base.new('//server//share//filename')
       expect(file.full_path).to eq(path)
     end
@@ -121,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
@@ -152,14 +150,14 @@ describe Puppet::FileServing::Base do
     end
 
     it "should accept Windows paths on Windows" do
-      allow(Puppet.features).to receive(:microsoft_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.features).to receive(:microsoft_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