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

data/spec/unit/util/backups_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/backups'
@@ -5,10 +6,10 @@ require 'puppet/util/backups'
 describe Puppet::Util::Backups do
   include PuppetSpec::Files
 
-  let(:bucket) { double('bucket', :name => "foo") }
+  let(:bucket) { stub('bucket', :name => "foo") }
   let!(:file) do
     f = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
-    allow(f).to receive(:bucket).and_return(bucket)
+    f.stubs(:bucket).returns(bucket)
     f
   end
 
@@ -18,8 +19,8 @@ describe Puppet::Util::Backups do
     it "should noop if the file does not exist" do
       file = Puppet::Type.type(:file).new(:name => path)
 
-      expect(file).not_to receive(:bucket)
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+      file.expects(:bucket).never
+      Puppet::FileSystem.expects(:exist?).with(path).returns false
 
       file.perform_backup
     end
@@ -27,24 +28,24 @@ describe Puppet::Util::Backups do
     it "should succeed silently if self[:backup] is false" do
       file = Puppet::Type.type(:file).new(:name => path, :backup => false)
 
-      expect(file).not_to receive(:bucket)
-      expect(Puppet::FileSystem).not_to receive(:exist?)
+      file.expects(:bucket).never
+      Puppet::FileSystem.expects(:exist?).never
 
       file.perform_backup
     end
 
     it "a bucket should be used when provided" do
       lstat_path_as(path, 'file')
-      expect(bucket).to receive(:backup).with(path).and_return("mysum")
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+      bucket.expects(:backup).with(path).returns("mysum")
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
       file.perform_backup
     end
 
     it "should propagate any exceptions encountered when backing up to a filebucket" do
       lstat_path_as(path, 'file')
-      expect(bucket).to receive(:backup).and_raise(ArgumentError)
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+      bucket.expects(:backup).raises ArgumentError
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
       expect { file.perform_backup }.to raise_error(ArgumentError)
     end
@@ -56,42 +57,42 @@ describe Puppet::Util::Backups do
 
       it "should remove any local backup if one exists" do
         lstat_path_as(backup, 'file')
-        expect(Puppet::FileSystem).to receive(:unlink).with(backup)
-        allow(FileUtils).to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.expects(:unlink).with(backup)
+        FileUtils.stubs(:cp_r)
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
         file.perform_backup
       end
 
       it "should fail when the old backup can't be removed" do
         lstat_path_as(backup, 'file')
-        expect(Puppet::FileSystem).to receive(:unlink).with(backup).and_raise(ArgumentError)
-        expect(FileUtils).not_to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.expects(:unlink).with(backup).raises ArgumentError
+        FileUtils.expects(:cp_r).never
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
         expect { file.perform_backup }.to raise_error(Puppet::Error)
       end
 
       it "should not try to remove backups that don't exist" do
-        expect(Puppet::FileSystem).to receive(:lstat).with(backup).and_raise(Errno::ENOENT)
-        expect(Puppet::FileSystem).not_to receive(:unlink).with(backup)
-        allow(FileUtils).to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.expects(:lstat).with(backup).raises(Errno::ENOENT)
+        Puppet::FileSystem.expects(:unlink).with(backup).never
+        FileUtils.stubs(:cp_r)
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
         file.perform_backup
       end
 
       it "a copy should be created in the local directory" do
-        expect(FileUtils).to receive(:cp_r).with(path, backup, :preserve => true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        FileUtils.expects(:cp_r).with(path, backup, :preserve => true)
+        Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
 
         expect(file.perform_backup).to be_truthy
       end
 
       it "should propagate exceptions if no backup can be created" do
-        expect(FileUtils).to receive(:cp_r).and_raise(ArgumentError)
+        FileUtils.expects(:cp_r).raises ArgumentError
 
-        allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
         expect { file.perform_backup }.to raise_error(Puppet::Error)
       end
     end
@@ -102,15 +103,15 @@ describe Puppet::Util::Backups do
     let(:filename) { File.join(path, 'file') }
 
     it "a bucket should work when provided" do
-      allow(File).to receive(:file?).with(filename).and_return(true)
-      expect(Find).to receive(:find).with(path).and_yield(filename)
+      File.stubs(:file?).with(filename).returns true
+      Find.expects(:find).with(path).yields(filename)
 
-      expect(bucket).to receive(:backup).with(filename).and_return(true)
+      bucket.expects(:backup).with(filename).returns true
 
       lstat_path_as(path, 'directory')
 
-      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).with(filename).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
+      Puppet::FileSystem.stubs(:exist?).with(filename).returns(true)
 
       file.perform_backup
     end
@@ -118,16 +119,16 @@ describe Puppet::Util::Backups do
     it "should do nothing when recursing" do
       file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo', :recurse => true)
 
-      expect(bucket).not_to receive(:backup)
-      stub_file = double('file', :stat => double('stat', :ftype => 'directory'))
-      allow(Puppet::FileSystem).to receive(:new).with(path).and_return(stub_file)
-      expect(Find).not_to receive(:find)
+      bucket.expects(:backup).never
+      stub_file = stub('file', :stat => stub('stat', :ftype => 'directory'))
+      Puppet::FileSystem.stubs(:new).with(path).returns stub_file
+      Find.expects(:find).never
 
       file.perform_backup
     end
   end
 
   def lstat_path_as(path, ftype)
-    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double('File::Stat', :ftype => ftype))
+    Puppet::FileSystem.expects(:lstat).with(path).returns(stub('File::Stat', :ftype => ftype))
   end
 end

data/spec/unit/util/character_encoding_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/character_encoding'
 require 'puppet_spec/character_encoding'
@@ -21,7 +22,7 @@ describe Puppet::Util::CharacterEncoding do
         let(:invalid_utf8_string) { "\xfd\xf1".force_encoding(Encoding::UTF_8) }
 
         it "should issue a debug message" do
-          expect(Puppet).to receive(:debug).with(/encoding is invalid/)
+          Puppet.expects(:debug).with(regexp_matches(/encoding is invalid/))
           Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_utf8_string)
         end
 
@@ -80,7 +81,7 @@ describe Puppet::Util::CharacterEncoding do
         end
 
         it "should issue a debug message that the string was not transcodable" do
-          expect(Puppet).to receive(:debug).with(/cannot be transcoded/)
+          Puppet.expects(:debug).with(regexp_matches(/cannot be transcoded/))
           PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
             Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_win_31j)
           end
@@ -124,7 +125,7 @@ describe Puppet::Util::CharacterEncoding do
           let(:euc_kr) { [253, 241].pack('C*').force_encoding(Encoding::ASCII) }
 
           it "should issue a debug message" do
-            expect(Puppet).to receive(:debug).with(/cannot be transcoded/)
+            Puppet.expects(:debug).with(regexp_matches(/cannot be transcoded/))
             Puppet::Util::CharacterEncoding.convert_to_utf_8(euc_kr)
           end
 
@@ -166,9 +167,8 @@ describe Puppet::Util::CharacterEncoding do
       # Invalid in UTF-8 without transcoding
       let(:oslash) { [216].pack('C*').force_encoding(Encoding::ISO_8859_1) }
       let(:foo) { 'foo' }
-
       it "should issue a debug message" do
-        expect(Puppet).to receive(:debug).with(/not valid UTF-8/)
+        Puppet.expects(:debug).with(regexp_matches(/not valid UTF-8/))
         Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(oslash)
       end
 
@@ -183,47 +183,4 @@ describe Puppet::Util::CharacterEncoding do
       end
     end
   end
-
-  describe "::scrub" do
-    let(:utf_8_string_to_scrub) { "\xfdfoo".force_encoding(Encoding::UTF_8) } # invalid in UTF-8
-    # The invalid-ness of this string comes from unpaired surrogates, ie:
-    #  "any value in the range D80016 to DBFF16 not followed by a value in the
-    #  range DC0016 to DFFF16, or any value in the range DC0016 to DFFF16 not
-    #  preceded by a value in the range D80016 to DBFF16"
-    # http://unicode.org/faq/utf_bom.html#utf16-7
-    # "a\ud800b"
-    # We expect the "b" to be replaced as that is what makes the string invalid
-    let(:utf_16LE_string_to_scrub) { [97, 237, 160, 128, 98].pack('C*').force_encoding(Encoding::UTF_16LE) } # invalid in UTF-16
-    let(:invalid_non_utf) { "foo\u2603".force_encoding(Encoding::EUC_KR) } # EUC_KR foosnowman!
-
-    it "should defer to String#scrub if defined", :if => String.method_defined?(:scrub) do
-      result = Puppet::Util::CharacterEncoding.scrub(utf_8_string_to_scrub)
-      # The result should have the UTF-8 replacement character if we're using Ruby scrub
-      expect(result).to eq("\uFFFDfoo".force_encoding(Encoding::UTF_8))
-      expect(result.bytes.to_a).to eq([239, 191, 189, 102, 111, 111])
-    end
-
-    context "when String#scrub is not defined" do
-      it "should still issue unicode replacement characters if the string is UTF-8" do
-        allow(utf_8_string_to_scrub).to receive(:respond_to?).with(:scrub).and_return(false)
-        result = Puppet::Util::CharacterEncoding.scrub(utf_8_string_to_scrub)
-        expect(result).to eq("\uFFFDfoo".force_encoding(Encoding::UTF_8))
-      end
-
-      it "should still issue unicode replacement characters if the string is UTF-16LE" do
-        allow(utf_16LE_string_to_scrub).to receive(:respond_to?).with(:scrub).and_return(false)
-        result = Puppet::Util::CharacterEncoding.scrub(utf_16LE_string_to_scrub)
-        # Bytes of replacement character on UTF_16LE are [253, 255]
-        # We just check for bytes because something (ruby?) interprets this array of bytes as:
-        # (97) (237 160) (128 253 255) rather than (97) (237 160 128) (253 255)
-        expect(result).to eq([97, 237, 160, 128, 253, 255].pack('C*').force_encoding(Encoding::UTF_16LE))
-      end
-
-      it "should issue '?' characters if the string is not one of UTF_8 or UTF_16LE" do
-        allow(invalid_non_utf).to receive(:respond_to?).with(:scrub).and_return(false)
-        result = Puppet::Util::CharacterEncoding.scrub(invalid_non_utf)
-        expect(result).to eq("foo???".force_encoding(Encoding::EUC_KR))
-      end
-    end
-  end
 end

data/spec/unit/util/checksums_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/checksums'
@@ -68,34 +69,34 @@ describe Puppet::Util::Checksums do
   {:md5 => Digest::MD5, :sha1 => Digest::SHA1, :sha256 => Digest::SHA256, :sha512 => Digest::SHA512, :sha384 => Digest::SHA384}.each do |sum, klass|
     describe("when using #{sum}") do
       it "should use #{klass} to calculate string checksums" do
-        expect(klass).to receive(:hexdigest).with("mycontent").and_return("whatever")
+        klass.expects(:hexdigest).with("mycontent").returns "whatever"
         expect(@summer.send(sum, "mycontent")).to eq("whatever")
       end
 
       it "should use incremental #{klass} sums to calculate file checksums" do
-        digest = double('digest')
-        expect(klass).to receive(:new).and_return(digest)
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
 
         file = "/path/to/my/file"
 
-        fh = double('filehandle')
-        expect(fh).to receive(:read).with(4096).exactly(3).times().and_return("firstline", "secondline", nil)
+        fh = mock 'filehandle'
+        fh.expects(:read).with(4096).times(3).returns("firstline").then.returns("secondline").then.returns(nil)
 
-        expect(File).to receive(:open).with(file, "rb").and_yield(fh)
+        File.expects(:open).with(file, "rb").yields(fh)
 
-        expect(digest).to receive(:<<).with("firstline")
-        expect(digest).to receive(:<<).with("secondline")
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
+        digest.expects(:<<).with "firstline"
+        digest.expects(:<<).with "secondline"
+        digest.expects(:hexdigest).returns :mydigest
 
         expect(@summer.send(sum.to_s + "_file", file)).to eq(:mydigest)
       end
 
       it "should behave like #{klass} to calculate stream checksums" do
-        digest = double('digest')
-        expect(klass).to receive(:new).and_return(digest)
-        expect(digest).to receive(:<<).with "firstline"
-        expect(digest).to receive(:<<).with "secondline"
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
+        digest.expects(:<<).with "firstline"
+        digest.expects(:<<).with "secondline"
+        digest.expects(:hexdigest).returns :mydigest
 
         expect(@summer.send(sum.to_s + "_stream") do |checksum|
           checksum << "firstline"
@@ -109,33 +110,33 @@ describe Puppet::Util::Checksums do
     describe("when using #{sum}") do
       it "should use #{klass} to calculate string checksums from the first 512 characters of the string" do
         content = "this is a test" * 100
-        expect(klass).to receive(:hexdigest).with(content[0..511]).and_return("whatever")
+        klass.expects(:hexdigest).with(content[0..511]).returns "whatever"
         expect(@summer.send(sum, content)).to eq("whatever")
       end
 
       it "should use #{klass} to calculate a sum from the first 512 characters in the file" do
-        digest = double('digest')
-        expect(klass).to receive(:new).and_return(digest)
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
 
         file = "/path/to/my/file"
 
-        fh = double('filehandle')
-        expect(fh).to receive(:read).with(512).and_return('my content')
+        fh = mock 'filehandle'
+        fh.expects(:read).with(512).returns('my content')
 
-        expect(File).to receive(:open).with(file, "rb").and_yield(fh)
+        File.expects(:open).with(file, "rb").yields(fh)
 
-        expect(digest).to receive(:<<).with("my content")
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
+        digest.expects(:<<).with "my content"
+        digest.expects(:hexdigest).returns :mydigest
 
         expect(@summer.send(sum.to_s + "_file", file)).to eq(:mydigest)
       end
 
       it "should use #{klass} to calculate a sum from the first 512 characters in a stream" do
-        digest = double('digest')
+        digest = mock 'digest'
         content = "this is a test" * 100
-        expect(klass).to receive(:new).and_return(digest)
-        expect(digest).to receive(:<<).with(content[0..511])
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
+        klass.expects(:new).returns digest
+        digest.expects(:<<).with content[0..511]
+        digest.expects(:hexdigest).returns :mydigest
 
         expect(@summer.send(sum.to_s + "_stream") do |checksum|
           checksum << content
@@ -143,13 +144,13 @@ describe Puppet::Util::Checksums do
       end
 
       it "should use #{klass} to calculate a sum from the first 512 characters in a multi-part stream" do
-        digest = double('digest')
+        digest = mock 'digest'
         content = "this is a test" * 100
-        expect(klass).to receive(:new).and_return(digest)
-        expect(digest).to receive(:<<).with(content[0..5])
-        expect(digest).to receive(:<<).with(content[6..510])
-        expect(digest).to receive(:<<).with(content[511..511])
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
+        klass.expects(:new).returns digest
+        digest.expects(:<<).with content[0..5]
+        digest.expects(:<<).with content[6..510]
+        digest.expects(:<<).with content[511..511]
+        digest.expects(:hexdigest).returns :mydigest
 
         expect(@summer.send(sum.to_s + "_stream") do |checksum|
           checksum << content[0..5]
@@ -164,15 +165,15 @@ describe Puppet::Util::Checksums do
     describe("when using #{sum}") do
       it "should use the '#{sum}' on the file to determine the ctime" do
         file = "/my/file"
-        stat = double('stat', sum => "mysum")
-        expect(Puppet::FileSystem).to receive(:stat).with(file).and_return(stat)
+        stat = mock 'stat', sum => "mysum"
+        Puppet::FileSystem.expects(:stat).with(file).returns(stat)
 
         expect(@summer.send(sum.to_s + "_file", file)).to eq("mysum")
       end
 
       it "should return nil for streams" do
-        expectation = double("expectation")
-        expect(expectation).to receive(:do_something!).at_least(:once)
+        expectation = stub "expectation"
+        expectation.expects(:do_something!).at_least_once
         expect(@summer.send(sum.to_s + "_stream"){ |checksum| checksum << "anything" ; expectation.do_something!  }).to be_nil
       end
     end
@@ -184,8 +185,8 @@ describe Puppet::Util::Checksums do
     end
 
     it "should return an empty string for streams" do
-      expectation = double("expectation")
-      expect(expectation).to receive(:do_something!).at_least(:once)
+      expectation = stub "expectation"
+      expectation.expects(:do_something!).at_least_once
       expect(@summer.none_stream{ |checksum| checksum << "anything" ; expectation.do_something!  }).to eq("")
     end
   end

data/spec/unit/util/colors_spec.rb

@@ -1,3 +1,4 @@
+#!/usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Util::Colors do
@@ -30,7 +31,7 @@ describe Puppet::Util::Colors do
       it "should colorize console output" do
         Puppet[:color] = true
 
-        expect(subject).to receive(:console_color).with(color, message)
+        subject.expects(:console_color).with(color, message)
         subject.colorize(:black, message)
       end
 

data/spec/unit/util/command_line_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/face'
@@ -66,37 +67,16 @@ describe Puppet::Util::CommandLine do
       end
     end
 
-    %w{--help -h help}.each do|arg|
-      it "should print help and exit if #{arg} is given" do
+    %w{--help -h}.each do|arg|
+      it "should print help" do
         commandline = Puppet::Util::CommandLine.new("puppet", [arg])
-        expect(commandline).not_to receive(:exec)
+        commandline.expects(:exec).never
 
         expect {
           commandline.execute
         }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
       end
     end
-
-    it "should fail if the config file isn't readable and we're running a subcommand that requires a readable config file" do
-      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:config]).and_return(true)
-      allow_any_instance_of(Puppet::Settings).to receive(:read_file).and_return('')
-      expect_any_instance_of(Puppet::Settings).to receive(:read_file).with(Puppet[:config]).and_raise('Permission denied')
-
-      expect{ described_class.new("puppet", ['config']).execute }.to raise_error(SystemExit)
-    end
-
-    it "should not fail if the config file isn't readable and we're running a subcommand that does not require a readable config file" do
-      allow(Puppet::FileSystem).to receive(:exist?)
-      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:config]).and_return(true)
-      allow_any_instance_of(Puppet::Settings).to receive(:read_file).and_return('')
-      expect_any_instance_of(Puppet::Settings).to receive(:read_file).with(Puppet[:config]).and_raise('Permission denied')
-
-      commandline = described_class.new("puppet", ['help'])
-
-      expect {
-        commandline.execute
-      }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
-    end
   end
 
   describe "when dealing with puppet commands" do
@@ -108,19 +88,19 @@ describe Puppet::Util::CommandLine do
     describe "when the subcommand is not implemented" do
       it "should find and invoke an executable with a hyphenated name" do
         commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
-        expect(Puppet::Util).to receive(:which).with('puppet-whatever').
-          and_return('/dev/null/puppet-whatever')
+        Puppet::Util.expects(:which).with('puppet-whatever').
+          returns('/dev/null/puppet-whatever')
 
-        expect(Kernel).to receive(:exec).with('/dev/null/puppet-whatever', 'argument')
+        Kernel.expects(:exec).with('/dev/null/puppet-whatever', 'argument')
 
         commandline.execute
       end
 
       describe "and an external implementation cannot be found" do
         it "should abort and show the usage message" do
-          expect(Puppet::Util).to receive(:which).with('puppet-whatever').and_return(nil)
+          Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
           commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
-          expect(commandline).not_to receive(:exec)
+          commandline.expects(:exec).never
 
           expect {
             commandline.execute
@@ -128,9 +108,9 @@ describe Puppet::Util::CommandLine do
         end
 
         it "should abort and show the help message" do
-          expect(Puppet::Util).to receive(:which).with('puppet-whatever').and_return(nil)
+          Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
           commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
-          expect(commandline).not_to receive(:exec)
+          commandline.expects(:exec).never
 
           expect {
             commandline.execute
@@ -139,9 +119,9 @@ describe Puppet::Util::CommandLine do
 
         %w{--version -V}.each do |arg|
           it "should abort and display #{arg} information" do
-            expect(Puppet::Util).to receive(:which).with('puppet-whatever').and_return(nil)
+            Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
             commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', arg])
-            expect(commandline).not_to receive(:exec)
+            commandline.expects(:exec).never
 
             expect {
               commandline.execute
@@ -157,11 +137,11 @@ describe Puppet::Util::CommandLine do
       end
 
       before :each do
-        allow_any_instance_of(Puppet::Util::CommandLine::ApplicationSubcommand).to receive(:run)
+        Puppet::Util::CommandLine::ApplicationSubcommand.any_instance.stubs(:run)
       end
 
       it 'should never set priority by default' do
-        expect(Process).not_to receive(:setpriority)
+        Process.expects(:setpriority).never
 
         command_line.execute
       end
@@ -169,15 +149,15 @@ describe Puppet::Util::CommandLine do
       it 'should lower the process priority if one has been specified' do
         Puppet[:priority] = 10
 
-        expect(Process).to receive(:setpriority).with(0, Process.pid, 10)
+        Process.expects(:setpriority).with(0, Process.pid, 10)
         command_line.execute
       end
 
       it 'should warn if trying to raise priority, but not privileged user' do
         Puppet[:priority] = -10
 
-        expect(Process).to receive(:setpriority).and_raise(Errno::EACCES, 'Permission denied')
-        expect(Puppet).to receive(:warning).with("Failed to set process priority to '-10'")
+        Process.expects(:setpriority).raises(Errno::EACCES, 'Permission denied')
+        Puppet.expects(:warning).with("Failed to set process priority to '-10'")
 
         command_line.execute
       end
@@ -185,8 +165,8 @@ describe Puppet::Util::CommandLine do
       it "should warn if the platform doesn't support `Process.setpriority`" do
         Puppet[:priority] = 15
 
-        expect(Process).to receive(:setpriority).and_raise(NotImplementedError, 'NotImplementedError: setpriority() function is unimplemented on this machine')
-        expect(Puppet).to receive(:warning).with("Failed to set process priority to '15'")
+        Process.expects(:setpriority).raises(NotImplementedError, 'NotImplementedError: setpriority() function is unimplemented on this machine')
+        Puppet.expects(:warning).with("Failed to set process priority to '15'")
 
         command_line.execute
       end