puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/util/network_device/transport/telnet_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 if Puppet.features.telnet?
@@ -7,7 +6,12 @@ if Puppet.features.telnet?
   describe Puppet::Util::NetworkDevice::Transport::Telnet do
 
     before(:each) do
-      TCPSocket.stubs(:open).returns stub_everything('tcp')
+      tcp = double(
+        'tcp',
+        :sync= => nil,
+        :binmode => nil,
+      )
+      allow(TCPSocket).to receive(:open).and_return(tcp)
       @transport = Puppet::Util::NetworkDevice::Transport::Telnet.new()
     end
 
@@ -16,7 +20,7 @@ if Puppet.features.telnet?
     end
 
     it "should not open any files" do
-      File.expects(:open).never
+      expect(File).not_to receive(:open)
       @transport.host = "localhost"
       @transport.port = 23
 
@@ -24,7 +28,7 @@ if Puppet.features.telnet?
     end
 
     it "should connect to the given host and port" do
-      Net::Telnet.expects(:new).with { |args| args["Host"] == "localhost" && args["Port"] == 23 }.returns stub_everything
+      expect(Net::Telnet).to receive(:new).with(hash_including("Host" => "localhost", "Port" => 23)).and_return(double("telnet connection"))
       @transport.host = "localhost"
       @transport.port = 23
 
@@ -33,7 +37,7 @@ if Puppet.features.telnet?
 
     it "should connect and specify the default prompt" do
       @transport.default_prompt = "prompt"
-      Net::Telnet.expects(:new).with { |args| args["Prompt"] == "prompt" }.returns stub_everything
+      expect(Net::Telnet).to receive(:new).with(hash_including("Prompt" => "prompt")).and_return(double("telnet connection"))
       @transport.host = "localhost"
       @transport.port = 23
 
@@ -42,29 +46,29 @@ if Puppet.features.telnet?
 
     describe "when connected" do
       before(:each) do
-        @telnet = stub_everything 'telnet'
-        Net::Telnet.stubs(:new).returns(@telnet)
+        @telnet = double('telnet')
+        allow(Net::Telnet).to receive(:new).and_return(@telnet)
         @transport.connect
       end
 
       it "should send line to the telnet session" do
-        @telnet.expects(:puts).with("line")
+        expect(@telnet).to receive(:puts).with("line")
         @transport.send("line")
       end
 
       describe "when expecting output" do
         it "should waitfor output on the telnet session" do
-          @telnet.expects(:waitfor).with(/regex/)
+          expect(@telnet).to receive(:waitfor).with(/regex/)
           @transport.expect(/regex/)
         end
 
         it "should return telnet session output" do
-          @telnet.expects(:waitfor).returns("output")
+          expect(@telnet).to receive(:waitfor).and_return("output")
           expect(@transport.expect(/regex/)).to eq("output")
         end
 
         it "should yield telnet session output to the given block" do
-          @telnet.expects(:waitfor).yields("output")
+          expect(@telnet).to receive(:waitfor).and_yield("output")
           @transport.expect(/regex/) { |out| expect(out).to eq("output") }
         end
       end
@@ -72,13 +76,13 @@ if Puppet.features.telnet?
 
     describe "when closing" do
       before(:each) do
-        @telnet = stub_everything 'telnet'
-        Net::Telnet.stubs(:new).returns(@telnet)
+        @telnet = double('telnet')
+        allow(Net::Telnet).to receive(:new).and_return(@telnet)
         @transport.connect
       end
 
       it "should close the telnet session" do
-        @telnet.expects(:close)
+        expect(@telnet).to receive(:close)
         @transport.close
       end
     end

data/spec/unit/util/network_device_spec.rb

@@ -1,11 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'ostruct'
 require 'puppet/util/network_device'
 
 describe Puppet::Util::NetworkDevice do
-
   before(:each) do
     @device = OpenStruct.new(:name => "name", :provider => "test", :url => "telnet://admin:password@127.0.0.1", :options => { :debug => false })
   end
@@ -23,25 +21,25 @@ describe Puppet::Util::NetworkDevice do
 
   describe "when initializing the remote network device singleton" do
     it "should load the network device code" do
-      Puppet::Util::NetworkDevice.expects(:require)
+      expect(Puppet::Util::NetworkDevice).to receive(:require)
       Puppet::Util::NetworkDevice.init(@device)
     end
 
     it "should create a network device instance" do
-      Puppet::Util::NetworkDevice.stubs(:require)
-      Puppet::Util::NetworkDevice::Test::Device.expects(:new).with("telnet://admin:password@127.0.0.1", :debug => false)
+      allow(Puppet::Util::NetworkDevice).to receive(:require)
+      expect(Puppet::Util::NetworkDevice::Test::Device).to receive(:new).with("telnet://admin:password@127.0.0.1", :debug => false)
       Puppet::Util::NetworkDevice.init(@device)
     end
 
     it "should raise an error if the remote device instance can't be created" do
-      Puppet::Util::NetworkDevice.stubs(:require).raises("error")
+      allow(Puppet::Util::NetworkDevice).to receive(:require).and_raise("error")
       expect { Puppet::Util::NetworkDevice.init(@device) }.to raise_error(RuntimeError, /Can't load test for name/)
     end
 
     it "should let caller to access the singleton device" do
-      device = stub 'device'
-      Puppet::Util::NetworkDevice.stubs(:require)
-      Puppet::Util::NetworkDevice::Test::Device.expects(:new).returns(device)
+      device = double('device')
+      allow(Puppet::Util::NetworkDevice).to receive(:require)
+      expect(Puppet::Util::NetworkDevice::Test::Device).to receive(:new).and_return(device)
       Puppet::Util::NetworkDevice.init(@device)
 
       expect(Puppet::Util::NetworkDevice.current).to eq(device)

data/spec/unit/util/package_spec.rb

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

data/spec/unit/util/pidlock_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/pidlock'
@@ -51,7 +50,7 @@ describe Puppet::Util::Pidlock do
     end
 
     it 'should create an empty lock file even when pid is missing' do
-      Process.stubs(:pid).returns('')
+      allow(Process).to receive(:pid).and_return('')
       @lock.lock
       expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
       expect(Puppet::FileSystem.read(@lock.file_path)).to be_empty
@@ -59,12 +58,12 @@ describe Puppet::Util::Pidlock do
 
     it 'should replace an existing empty lockfile with a pid, given a subsequent lock call made against a valid pid' do
       # empty pid results in empty lockfile
-      Process.stubs(:pid).returns('')
+      allow(Process).to receive(:pid).and_return('')
       @lock.lock
       expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
 
       # next lock call with valid pid kills existing empty lockfile
-      Process.stubs(:pid).returns(1234)
+      allow(Process).to receive(:pid).and_return(1234)
       @lock.lock
       expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
       expect(Puppet::FileSystem.read(@lock.file_path)).to eq('1234')
@@ -105,7 +104,7 @@ describe Puppet::Util::Pidlock do
     end
 
     it "should remove the lockfile when pid is missing" do
-      Process.stubs(:pid).returns('')
+      allow(Process).to receive(:pid).and_return('')
       @lock.lock
       expect(@lock.locked?).to be_falsey
       expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_falsey
@@ -115,7 +114,7 @@ describe Puppet::Util::Pidlock do
   describe '#lock_pid' do
     it 'should return nil if the pid is empty' do
       # fake pid to get empty lockfile
-      Process.stubs(:pid).returns('')
+      allow(Process).to receive(:pid).and_return('')
       @lock.lock
       expect(@lock.lock_pid).to eq(nil)
     end
@@ -124,15 +123,15 @@ describe Puppet::Util::Pidlock do
   describe "with a stale lock" do
     before(:each) do
       # fake our pid to be 1234
-      Process.stubs(:pid).returns(1234)
+      allow(Process).to receive(:pid).and_return(1234)
       # lock the file
       @lock.lock
       # fake our pid to be a different pid, to simulate someone else
       #  holding the lock
-      Process.stubs(:pid).returns(6789)
+      allow(Process).to receive(:pid).and_return(6789)
 
-      Process.stubs(:kill).with(0, 6789)
-      Process.stubs(:kill).with(0, 1234).raises(Errno::ESRCH)
+      allow(Process).to receive(:kill).with(0, 6789)
+      allow(Process).to receive(:kill).with(0, 1234).and_raise(Errno::ESRCH)
     end
 
     it "should not be locked" do
@@ -169,15 +168,15 @@ describe Puppet::Util::Pidlock do
   describe "with another process lock" do
     before(:each) do
       # fake our pid to be 1234
-      Process.stubs(:pid).returns(1234)
+      allow(Process).to receive(:pid).and_return(1234)
       # lock the file
       @lock.lock
       # fake our pid to be a different pid, to simulate someone else
       #  holding the lock
-      Process.stubs(:pid).returns(6789)
+      allow(Process).to receive(:pid).and_return(6789)
 
-      Process.stubs(:kill).with(0, 6789)
-      Process.stubs(:kill).with(0, 1234)
+      allow(Process).to receive(:kill).with(0, 6789)
+      allow(Process).to receive(:kill).with(0, 1234)
     end
 
     it "should be locked" do

data/spec/unit/util/plist_spec.rb

@@ -69,55 +69,60 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
 
   describe "#read_plist_file" do
     it "calls #convert_cfpropertylist_to_native_types on a plist object when a valid binary plist is read" do
-      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns(binary_plist_magic_number)
-      subject.stubs(:new_cfpropertylist).with({:file => plist_path}).returns('plist_object')
-      subject.expects(:convert_cfpropertylist_to_native_types).with('plist_object').returns('plist_hash')
+      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return(binary_plist_magic_number)
+      allow(subject).to receive(:new_cfpropertylist).with({:file => plist_path}).and_return('plist_object')
+      expect(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object').and_return('plist_hash')
       expect(subject.read_plist_file(plist_path)).to eq('plist_hash')
     end
+
     it "returns a valid hash when a valid XML plist is read" do
-      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
-      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(valid_xml_plist)
+      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
+      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(valid_xml_plist)
       expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
     end
+
     it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
-      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
-      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(bad_xml_doctype)
-      subject.expects(:new_cfpropertylist).with({:data => good_xml_doctype}).returns('plist_object')
-      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object').returns('plist_hash')
-      Puppet.expects(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
+      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
+      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(bad_xml_doctype)
+      expect(subject).to receive(:new_cfpropertylist).with({:data => good_xml_doctype}).and_return('plist_object')
+      allow(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object').and_return('plist_hash')
+      expect(Puppet).to receive(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
       expect(subject.read_plist_file(plist_path)).to eq('plist_hash')
     end
+
     it "attempts to read pure xml using plutil when reading an improperly formatted service plist" do
-      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
-      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(invalid_xml_plist)
-      Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
-      Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute)
+      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
+      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(invalid_xml_plist)
+      expect(Puppet).to receive(:debug).with(/^Failed with CFFormatError/)
+      expect(Puppet).to receive(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
+      expect(Puppet::Util::Execution).to receive(:execute)
         .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
               {:failonfail => true, :combine => true})
-        .returns(Puppet::Util::Execution::ProcessOutput.new(valid_xml_plist, 0))
+        .and_return(Puppet::Util::Execution::ProcessOutput.new(valid_xml_plist, 0))
       expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
     end
+
     it "returns nil when direct parsing and plutil conversion both fail" do
-      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
-      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(non_plist_data)
-      Puppet.expects(:debug).with(regexp_matches(/^Failed with (CFFormatError|NoMethodError)/))
-      Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute)
+      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
+      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(non_plist_data)
+      expect(Puppet).to receive(:debug).with(/^Failed with (CFFormatError|NoMethodError)/)
+      expect(Puppet).to receive(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
+      expect(Puppet::Util::Execution).to receive(:execute)
         .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
               {:failonfail => true, :combine => true})
-        .raises(Puppet::ExecutionFailure, 'boom')
+        .and_raise(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end
+
     it "returns nil when file is a non-plist binary blob" do
-      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
-      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(binary_data)
-      Puppet.expects(:debug).with(regexp_matches(/^Failed with (CFFormatError|ArgumentError)/))
-      Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute)
+      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
+      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(binary_data)
+      expect(Puppet).to receive(:debug).with(/^Failed with (CFFormatError|ArgumentError)/)
+      expect(Puppet).to receive(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
+      expect(Puppet::Util::Execution).to receive(:execute)
         .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
               {:failonfail => true, :combine => true})
-        .raises(Puppet::ExecutionFailure, 'boom')
+        .and_raise(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end
   end
@@ -126,15 +131,17 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
     it "returns a valid hash when a valid XML plist is provided" do
       expect(subject.parse_plist(valid_xml_plist)).to eq(valid_xml_plist_hash)
     end
+
     it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
-      subject.expects(:new_cfpropertylist).with({:data => good_xml_doctype}).returns('plist_object')
-      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object')
-      Puppet.expects(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
+      expect(subject).to receive(:new_cfpropertylist).with({:data => good_xml_doctype}).and_return('plist_object')
+      allow(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object')
+      expect(Puppet).to receive(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
       subject.parse_plist(bad_xml_doctype, plist_path)
     end
+
     it "raises a debug message with malformed plist" do
-      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object')
-      Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
+      allow(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object')
+      expect(Puppet).to receive(:debug).with(/^Failed with CFFormatError/)
       subject.parse_plist("<plist><dict><key>Foo</key>")
     end
   end

data/spec/unit/util/posix_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/posix'
@@ -21,16 +20,20 @@ describe Puppet::Util::POSIX do
         ['group3', ['user1']],
         ['group4', ['user2']]
       ].map do |(name, members)|
-        group_struct = stub("Group #{name}")
-        group_struct.stubs(:name).returns(name)
-        group_struct.stubs(:mem).returns(members)
+        group_struct = double("Group #{name}")
+        allow(group_struct).to receive(:name).and_return(name)
+        allow(group_struct).to receive(:mem).and_return(members)
 
         group_struct
       end
     end
 
     before(:each) do
-      Puppet::Etc.stubs(:group).multiple_yields(*mock_groups)
+      etc_stub = receive(:group)
+      mock_groups.each do |mock_group|
+        etc_stub = etc_stub.and_yield(mock_group)
+      end
+      allow(Puppet::Etc).to etc_stub
     end
 
     it 'returns the groups of the given user' do
@@ -70,7 +73,7 @@ describe Puppet::Util::POSIX do
 
   describe "when retrieving a posix field" do
     before do
-      @thing = stub 'thing', :field => "asdf"
+      @thing = double('thing', :field => "asdf")
     end
 
     it "should fail if no id was passed" do
@@ -80,23 +83,23 @@ describe Puppet::Util::POSIX do
     describe "and the id is an integer" do
       it "should log an error and return nil if the specified id is greater than the maximum allowed ID" do
         Puppet[:maximum_uid] = 100
-        Puppet.expects(:err)
+        expect(Puppet).to receive(:err)
 
         expect(@posix.get_posix_field("asdf", "bar", 200)).to be_nil
       end
 
       it "should use the method return by :methodbyid and return the specified field" do
-        Etc.expects(:getgrgid).returns @thing
+        expect(Etc).to receive(:getgrgid).and_return(@thing)
 
-        @thing.expects(:field).returns "myval"
+        expect(@thing).to receive(:field).and_return("myval")
 
         expect(@posix.get_posix_field(:gr, :field, 200)).to eq("myval")
       end
 
       it "should return nil if the method throws an exception" do
-        Etc.expects(:getgrgid).raises ArgumentError
+        expect(Etc).to receive(:getgrgid).and_raise(ArgumentError)
 
-        @thing.expects(:field).never
+        expect(@thing).not_to receive(:field)
 
         expect(@posix.get_posix_field(:gr, :field, 200)).to be_nil
       end
@@ -104,17 +107,17 @@ describe Puppet::Util::POSIX do
 
     describe "and the id is not an integer" do
       it "should use the method return by :methodbyid and return the specified field" do
-        Etc.expects(:getgrnam).returns @thing
+        expect(Etc).to receive(:getgrnam).and_return(@thing)
 
-        @thing.expects(:field).returns "myval"
+        expect(@thing).to receive(:field).and_return("myval")
 
         expect(@posix.get_posix_field(:gr, :field, "asdf")).to eq("myval")
       end
 
       it "should return nil if the method throws an exception" do
-        Etc.expects(:getgrnam).raises ArgumentError
+        expect(Etc).to receive(:getgrnam).and_raise(ArgumentError)
 
-        @thing.expects(:field).never
+        expect(@thing).not_to receive(:field)
 
         expect(@posix.get_posix_field(:gr, :field, "asdf")).to be_nil
       end
@@ -123,32 +126,32 @@ describe Puppet::Util::POSIX do
 
   describe "when returning the gid" do
     before do
-      @posix.stubs(:get_posix_field)
+      allow(@posix).to receive(:get_posix_field)
     end
 
     describe "and the group is an integer" do
       it "should convert integers specified as a string into an integer" do
-        @posix.expects(:get_posix_field).with(:group, :name, 100)
+        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100)
 
         @posix.gid("100")
       end
 
       it "should look up the name for the group" do
-        @posix.expects(:get_posix_field).with(:group, :name, 100)
+        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100)
 
         @posix.gid(100)
       end
 
       it "should return nil if the group cannot be found" do
-        @posix.expects(:get_posix_field).once.returns nil
-        @posix.expects(:search_posix_field).never
+        expect(@posix).to receive(:get_posix_field).once.and_return(nil)
+        expect(@posix).not_to receive(:search_posix_field)
 
         expect(@posix.gid(100)).to be_nil
       end
 
       it "should use the found name to look up the id" do
-        @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
-        @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
+        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100).and_return("asdf")
+        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf").and_return(100)
 
         expect(@posix.gid(100)).to eq(100)
       end
@@ -156,10 +159,10 @@ describe Puppet::Util::POSIX do
       # LAK: This is because some platforms have a broken Etc module that always return
       # the same group.
       it "should use :search_posix_field if the discovered id does not match the passed-in id" do
-        @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
-        @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 50
+        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100).and_return("asdf")
+        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf").and_return(50)
 
-        @posix.expects(:search_posix_field).with(:group, :gid, 100).returns "asdf"
+        expect(@posix).to receive(:search_posix_field).with(:group, :gid, 100).and_return("asdf")
 
         expect(@posix.gid(100)).to eq("asdf")
       end
@@ -167,30 +170,30 @@ describe Puppet::Util::POSIX do
 
     describe "and the group is a string" do
       it "should look up the gid for the group" do
-        @posix.expects(:get_posix_field).with(:group, :gid, "asdf")
+        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf")
 
         @posix.gid("asdf")
       end
 
       it "should return nil if the group cannot be found" do
-        @posix.expects(:get_posix_field).once.returns nil
-        @posix.expects(:search_posix_field).never
+        expect(@posix).to receive(:get_posix_field).once.and_return(nil)
+        expect(@posix).not_to receive(:search_posix_field)
 
         expect(@posix.gid("asdf")).to be_nil
       end
 
       it "should use the found gid to look up the nam" do
-        @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
-        @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
+        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf").and_return(100)
+        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100).and_return("asdf")
 
         expect(@posix.gid("asdf")).to eq(100)
       end
 
       it "should use :search_posix_field if the discovered name does not match the passed-in name" do
-        @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
-        @posix.expects(:get_posix_field).with(:group, :name, 100).returns "boo"
+        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf").and_return(100)
+        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100).and_return("boo")
 
-        @posix.expects(:search_posix_field).with(:group, :gid, "asdf").returns "asdf"
+        expect(@posix).to receive(:search_posix_field).with(:group, :gid, "asdf").and_return("asdf")
 
         expect(@posix.gid("asdf")).to eq("asdf")
       end
@@ -199,32 +202,32 @@ describe Puppet::Util::POSIX do
 
   describe "when returning the uid" do
     before do
-      @posix.stubs(:get_posix_field)
+      allow(@posix).to receive(:get_posix_field)
     end
 
     describe "and the group is an integer" do
       it "should convert integers specified as a string into an integer" do
-        @posix.expects(:get_posix_field).with(:passwd, :name, 100)
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100)
 
         @posix.uid("100")
       end
 
       it "should look up the name for the group" do
-        @posix.expects(:get_posix_field).with(:passwd, :name, 100)
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100)
 
         @posix.uid(100)
       end
 
       it "should return nil if the group cannot be found" do
-        @posix.expects(:get_posix_field).once.returns nil
-        @posix.expects(:search_posix_field).never
+        expect(@posix).to receive(:get_posix_field).once.and_return(nil)
+        expect(@posix).not_to receive(:search_posix_field)
 
         expect(@posix.uid(100)).to be_nil
       end
 
       it "should use the found name to look up the id" do
-        @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
-        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100).and_return("asdf")
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf").and_return(100)
 
         expect(@posix.uid(100)).to eq(100)
       end
@@ -232,10 +235,10 @@ describe Puppet::Util::POSIX do
       # LAK: This is because some platforms have a broken Etc module that always return
       # the same group.
       it "should use :search_posix_field if the discovered id does not match the passed-in id" do
-        @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
-        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 50
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100).and_return("asdf")
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf").and_return(50)
 
-        @posix.expects(:search_posix_field).with(:passwd, :uid, 100).returns "asdf"
+        expect(@posix).to receive(:search_posix_field).with(:passwd, :uid, 100).and_return("asdf")
 
         expect(@posix.uid(100)).to eq("asdf")
       end
@@ -243,30 +246,30 @@ describe Puppet::Util::POSIX do
 
     describe "and the group is a string" do
       it "should look up the uid for the group" do
-        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf")
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf")
 
         @posix.uid("asdf")
       end
 
       it "should return nil if the group cannot be found" do
-        @posix.expects(:get_posix_field).once.returns nil
-        @posix.expects(:search_posix_field).never
+        expect(@posix).to receive(:get_posix_field).once.and_return(nil)
+        expect(@posix).not_to receive(:search_posix_field)
 
         expect(@posix.uid("asdf")).to be_nil
       end
 
       it "should use the found uid to look up the nam" do
-        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
-        @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf").and_return(100)
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100).and_return("asdf")
 
         expect(@posix.uid("asdf")).to eq(100)
       end
 
       it "should use :search_posix_field if the discovered name does not match the passed-in name" do
-        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
-        @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "boo"
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf").and_return(100)
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100).and_return("boo")
 
-        @posix.expects(:search_posix_field).with(:passwd, :uid, "asdf").returns "asdf"
+        expect(@posix).to receive(:search_posix_field).with(:passwd, :uid, "asdf").and_return("asdf")
 
         expect(@posix.uid("asdf")).to eq("asdf")
       end