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

data/spec/unit/util/metric_spec.rb

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

data/spec/unit/util/monkey_patches_spec.rb

@@ -1,7 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/monkey_patches'
 
+
 describe Symbol do
   after :all do
     $unique_warnings.delete('symbol_comparison') if $unique_warnings
@@ -52,7 +54,7 @@ describe OpenSSL::SSL::SSLContext do
   end
 
   it 'sets parameters on initialization' do
-    expect_any_instance_of(described_class).to receive(:set_params)
+    described_class.any_instance.expects(:set_params)
     subject
   end
 
@@ -71,7 +73,7 @@ describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
   let(:samecert) { cert.dup() }
 
   def with_root_certs(certs)
-    expect(Puppet::Util::Windows::RootCerts).to receive(:instance).and_return(certs)
+    Puppet::Util::Windows::RootCerts.expects(:instance).returns(certs)
   end
 
   it "adds a root cert to the store" do
@@ -82,7 +84,7 @@ describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
 
   it "doesn't warn when calling set_default_paths multiple times" do
     with_root_certs([cert])
-    expect(store).not_to receive(:warn)
+    store.expects(:warn).never
 
     store.set_default_paths
     store.set_default_paths
@@ -93,8 +95,8 @@ describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
     expect(cert.hash).to_not eq(samecert.hash)
     with_root_certs([cert, samecert])
 
-    expect(store).to receive(:add_cert).with(cert).once
-    expect(store).not_to receive(:add_cert).with(samecert)
+    store.expects(:add_cert).with(cert).once
+    store.expects(:add_cert).with(samecert).never
 
     store.set_default_paths
   end
@@ -106,7 +108,7 @@ describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
       with_root_certs([cert])
       store.add_cert(cert)
 
-      expect(store).to receive(:warn).with('Failed to add /DC=com/DC=microsoft/CN=Microsoft Root Certificate Authority')
+      store.expects(:warn).with('Failed to add /DC=com/DC=microsoft/CN=Microsoft Root Certificate Authority')
 
       store.set_default_paths
     end
@@ -115,7 +117,7 @@ describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
       with_root_certs([cert])
       store.add_cert(cert)
 
-      expect(store).not_to receive(:warn)
+      store.expects(:warn).never
 
       store.set_default_paths
     end

data/spec/unit/util/multi_match_spec.rb

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

data/spec/unit/util/network_device/config_spec.rb

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

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device/transport/base'
@@ -12,28 +13,28 @@ describe Puppet::Util::NetworkDevice::Transport::Base do
 
   describe "when sending commands" do
     it "should send the command to the telnet session" do
-      expect(@transport).to receive(:send).with("line")
+      @transport.expects(:send).with("line")
       @transport.command("line")
     end
 
     it "should expect an output matching the given prompt" do
-      expect(@transport).to receive(:expect).with(/prompt/)
+      @transport.expects(:expect).with(/prompt/)
       @transport.command("line", :prompt => /prompt/)
     end
 
     it "should expect an output matching the default prompt" do
       @transport.default_prompt = /defprompt/
-      expect(@transport).to receive(:expect).with(/defprompt/)
+      @transport.expects(:expect).with(/defprompt/)
       @transport.command("line")
     end
 
     it "should yield telnet output to the given block" do
-      expect(@transport).to receive(:expect).and_yield("output")
+      @transport.expects(:expect).yields("output")
       @transport.command("line") { |out| expect(out).to eq("output") }
     end
 
     it "should return telnet output to the caller" do
-      expect(@transport).to receive(:expect).and_return("output")
+      @transport.expects(:expect).returns("output")
       expect(@transport.command("line")).to eq("output")
     end
   end

data/spec/unit/util/network_device_spec.rb

@@ -1,9 +1,11 @@
+#! /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
@@ -21,25 +23,25 @@ describe Puppet::Util::NetworkDevice do
 
   describe "when initializing the remote network device singleton" do
     it "should load the network device code" do
-      expect(Puppet::Util::NetworkDevice).to receive(:require)
+      Puppet::Util::NetworkDevice.expects(:require)
       Puppet::Util::NetworkDevice.init(@device)
     end
 
     it "should create a network device instance" do
-      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.stubs(:require)
+      Puppet::Util::NetworkDevice::Test::Device.expects(: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
-      allow(Puppet::Util::NetworkDevice).to receive(:require).and_raise("error")
+      Puppet::Util::NetworkDevice.stubs(:require).raises("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 = double('device')
-      allow(Puppet::Util::NetworkDevice).to receive(:require)
-      expect(Puppet::Util::NetworkDevice::Test::Device).to receive(:new).and_return(device)
+      device = stub 'device'
+      Puppet::Util::NetworkDevice.stubs(:require)
+      Puppet::Util::NetworkDevice::Test::Device.expects(:new).returns(device)
       Puppet::Util::NetworkDevice.init(@device)
 
       expect(Puppet::Util::NetworkDevice.current).to eq(device)

data/spec/unit/util/package_spec.rb

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

data/spec/unit/util/pidlock_spec.rb

@@ -1,8 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/pidlock'
 
-describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
+describe Puppet::Util::Pidlock do
   require 'puppet_spec/files'
   include PuppetSpec::Files
 
@@ -22,23 +23,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
 
     it "should become locked" do
       @lock.lock
-      if Puppet::Util::Platform.windows?
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-      else
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('puppet')
-      end
-      expect(@lock).to be_locked
-    end
-
-    it "should become locked if puppet is a gem" do
-      @lock.lock
-      unless Puppet::Util::Platform.windows?
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      else
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\tools\ruby25\bin\ruby.exe')
-      end
       expect(@lock).to be_locked
     end
 
@@ -67,7 +51,7 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
     end
 
     it 'should create an empty lock file even when pid is missing' do
-      allow(Process).to receive(:pid).and_return('')
+      Process.stubs(:pid).returns('')
       @lock.lock
       expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
       expect(Puppet::FileSystem.read(@lock.file_path)).to be_empty
@@ -75,12 +59,12 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? 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
-      allow(Process).to receive(:pid).and_return('')
+      Process.stubs(:pid).returns('')
       @lock.lock
       expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
 
       # next lock call with valid pid kills existing empty lockfile
-      allow(Process).to receive(:pid).and_return(1234)
+      Process.stubs(:pid).returns(1234)
       @lock.lock
       expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
       expect(Puppet::FileSystem.read(@lock.file_path)).to eq('1234')
@@ -117,28 +101,11 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
   describe "#locked?" do
     it "should return true if locked" do
       @lock.lock
-      if Puppet::Util::Platform.windows?
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-      else
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('puppet')
-      end
-      expect(@lock).to be_locked
-    end
-
-    it "should return true if locked when puppet as gem" do
-      @lock.lock
-      unless Puppet::Util::Platform.windows?
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      else
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\tools\ruby25\bin\ruby.exe')
-      end
       expect(@lock).to be_locked
     end
 
     it "should remove the lockfile when pid is missing" do
-      allow(Process).to receive(:pid).and_return('')
+      Process.stubs(:pid).returns('')
       @lock.lock
       expect(@lock.locked?).to be_falsey
       expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_falsey
@@ -148,7 +115,7 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
   describe '#lock_pid' do
     it 'should return nil if the pid is empty' do
       # fake pid to get empty lockfile
-      allow(Process).to receive(:pid).and_return('')
+      Process.stubs(:pid).returns('')
       @lock.lock
       expect(@lock.lock_pid).to eq(nil)
     end
@@ -157,15 +124,15 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
   describe "with a stale lock" do
     before(:each) do
       # fake our pid to be 1234
-      allow(Process).to receive(:pid).and_return(1234)
+      Process.stubs(:pid).returns(1234)
       # lock the file
       @lock.lock
       # fake our pid to be a different pid, to simulate someone else
       #  holding the lock
-      allow(Process).to receive(:pid).and_return(6789)
+      Process.stubs(:pid).returns(6789)
 
-      allow(Process).to receive(:kill).with(0, 6789)
-      allow(Process).to receive(:kill).with(0, 1234).and_raise(Errno::ESRCH)
+      Process.stubs(:kill).with(0, 6789)
+      Process.stubs(:kill).with(0, 1234).raises(Errno::ESRCH)
     end
 
     it "should not be locked" do
@@ -179,12 +146,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
       end
 
       it "should replace with new locks" do
-        if Puppet::Util::Platform.windows?
-          allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(6789).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-        else
-          allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 6789, '-o', 'comm=']).and_return('puppet')
-          allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 6789, '-o', 'args=']).and_return('puppet')
-        end
         @lock.lock
         expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
         expect(@lock.lock_pid).to eq(6789)
@@ -208,21 +169,15 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
   describe "with another process lock" do
     before(:each) do
       # fake our pid to be 1234
-      allow(Process).to receive(:pid).and_return(1234)
-      if Puppet::Util::Platform.windows?
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(1234).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-      else
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('puppet')
-      end
+      Process.stubs(:pid).returns(1234)
       # lock the file
       @lock.lock
       # fake our pid to be a different pid, to simulate someone else
       #  holding the lock
-      allow(Process).to receive(:pid).and_return(6789)
+      Process.stubs(:pid).returns(6789)
 
-      allow(Process).to receive(:kill).with(0, 6789)
-      allow(Process).to receive(:kill).with(0, 1234)
+      Process.stubs(:kill).with(0, 6789)
+      Process.stubs(:kill).with(0, 1234)
     end
 
     it "should be locked" do

data/spec/unit/util/plist_spec.rb

@@ -69,60 +69,55 @@ 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
-      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')
+      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')
       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
-      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)
+      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)
       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
-      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}")
+      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}")
       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
-      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)
+      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)
         .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
               {:failonfail => true, :combine => true})
-        .and_return(Puppet::Util::Execution::ProcessOutput.new(valid_xml_plist, 0))
+        .returns(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
-      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)
+      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)
         .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
               {:failonfail => true, :combine => true})
-        .and_raise(Puppet::ExecutionFailure, 'boom')
+        .raises(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
-      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)
+      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)
         .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
               {:failonfail => true, :combine => true})
-        .and_raise(Puppet::ExecutionFailure, 'boom')
+        .raises(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end
   end
@@ -131,17 +126,15 @@ 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
-      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.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}")
       subject.parse_plist(bad_xml_doctype, plist_path)
     end
-
     it "raises a debug message with malformed plist" do
-      allow(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object')
-      expect(Puppet).to receive(:debug).with(/^Failed with CFFormatError/)
+      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object')
+      Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
       subject.parse_plist("<plist><dict><key>Foo</key>")
     end
   end

data/spec/unit/util/posix_spec.rb

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