puppet 5.3.4 → 6.29.0

data/spec/unit/util/posix_spec.rb

@@ -1,6 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
+require 'puppet/ffi/posix'
 require 'puppet/util/posix'
 
 class PosixTest
@@ -12,6 +12,347 @@ describe Puppet::Util::POSIX do
     @posix = PosixTest.new
   end
 
+  describe '.groups_of' do 
+    let(:mock_user_data) { double(user, :gid => 1000) }
+
+    let(:ngroups_ptr) { double('FFI::MemoryPointer', :address => 0x0001, :size => 4) }
+    let(:groups_ptr) { double('FFI::MemoryPointer', :address => 0x0002, :size => Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS) }
+
+    let(:mock_groups) do
+      [
+        ['root', ['root'], 0],
+        ['nomembers', [], 5 ],
+        ['group1', ['user1', 'user2'], 1001],
+        ['group2', ['user2'], 2002],
+        ['group1', ['user1', 'user2'], 1001],
+        ['group3', ['user1'], 3003],
+        ['group4', ['user2'], 4004],
+        ['user1', [], 1111],
+        ['user2', [], 2222]
+      ].map do |(name, members, gid)|
+        group_struct = double("Group #{name}")
+        allow(group_struct).to receive(:name).and_return(name)
+        allow(group_struct).to receive(:mem).and_return(members)
+        allow(group_struct).to receive(:gid).and_return(gid)
+
+        group_struct
+      end
+    end
+
+    def prepare_user_and_groups_env(user, groups)
+      groups_gids = []
+      groups_and_user = []
+      groups_and_user.replace(groups)
+      groups_and_user.push(user)
+
+      groups_and_user.each do |group|
+        mock_group = mock_groups.find { |m| m.name == group }
+        groups_gids.push(mock_group.gid)
+
+        allow(Puppet::Etc).to receive(:getgrgid).with(mock_group.gid).and_return(mock_group)
+      end
+
+      if groups_and_user.size > Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS
+        allow(ngroups_ptr).to receive(:read_int).and_return(Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS, groups_and_user.size)
+      else
+        allow(ngroups_ptr).to receive(:read_int).and_return(groups_and_user.size)
+      end
+
+      allow(groups_ptr).to receive(:get_array_of_uint).with(0, groups_and_user.size).and_return(groups_gids)
+      allow(Puppet::Etc).to receive(:getpwnam).with(user).and_return(mock_user_data)
+    end
+
+    before(:each) do
+      allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist, any_args).and_return(true)
+    end
+
+    describe 'when it uses FFI function getgrouplist' do
+      before(:each) do
+        allow(FFI::MemoryPointer).to receive(:new).with(:int).and_yield(ngroups_ptr)
+        allow(FFI::MemoryPointer).to receive(:new).with(:uint, Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS).and_yield(groups_ptr)
+        allow(ngroups_ptr).to receive(:write_int).with(Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS).and_return(ngroups_ptr)
+      end
+
+      describe 'when there are groups' do
+        context 'for user1' do
+          let(:user) { 'user1' }
+          let(:expected_groups) { ['group1', 'group3'] }
+
+          before(:each) do
+            prepare_user_and_groups_env(user, expected_groups)
+            allow(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).and_return(1)
+          end
+
+          it "should return the groups for given user" do
+            expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+          end
+
+          it 'should not print any debug message about falling back to Puppet::Etc.group' do
+            expect(Puppet).not_to receive(:debug).with(/Falling back to Puppet::Etc.group:/)
+            Puppet::Util::POSIX.groups_of(user)
+          end
+        end
+
+        context 'for user2' do
+          let(:user) { 'user2' }
+          let(:expected_groups) { ['group1', 'group2', 'group4'] }
+
+          before(:each) do
+            prepare_user_and_groups_env(user, expected_groups)
+            allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist, any_args).and_return(true)
+            allow(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).and_return(1)
+          end
+
+          it "should return the groups for given user" do
+            expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+          end
+
+          it 'should not print any debug message about falling back to Puppet::Etc.group' do
+            expect(Puppet).not_to receive(:debug).with(/Falling back to Puppet::Etc.group:/)
+            Puppet::Util::POSIX.groups_of(user)
+          end
+        end
+      end
+
+      describe 'when there are no groups' do
+        let(:user) { 'nomembers' }
+        let(:expected_groups) { [] }
+
+        before(:each) do
+          prepare_user_and_groups_env(user, expected_groups)
+          allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist, any_args).and_return(true)
+          allow(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).and_return(1)
+        end
+
+        it "should return no groups for given user" do
+          expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+        end
+
+        it 'should not print any debug message about falling back to Puppet::Etc.group' do
+          expect(Puppet).not_to receive(:debug).with(/Falling back to Puppet::Etc.group:/)
+          Puppet::Util::POSIX.groups_of(user)
+        end
+      end
+
+      describe 'when primary group explicitly contains user' do
+        let(:user) { 'root' }
+        let(:expected_groups) { ['root'] }
+
+        before(:each) do
+          prepare_user_and_groups_env(user, expected_groups)
+          allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist, any_args).and_return(true)
+          allow(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).and_return(1)
+        end
+
+        it "should return the groups, including primary group, for given user" do
+          expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+        end
+
+        it 'should not print any debug message about falling back to Puppet::Etc.group' do
+          expect(Puppet).not_to receive(:debug).with(/Falling back to Puppet::Etc.group:/)
+          Puppet::Util::POSIX.groups_of(user)
+        end
+      end
+
+      describe 'when primary group does not explicitly contain user' do
+        let(:user) { 'user1' }
+        let(:expected_groups) { ['group1', 'group3'] }
+
+        before(:each) do
+          prepare_user_and_groups_env(user, expected_groups)
+          allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist, any_args).and_return(true)
+          allow(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).and_return(1)
+        end
+
+        it "should not return primary group for given user" do
+          expect(Puppet::Util::POSIX.groups_of(user)).not_to include(user)
+        end
+
+        it 'should not print any debug message about falling back to Puppet::Etc.group' do
+          expect(Puppet).not_to receive(:debug).with(/Falling back to Puppet::Etc.group:/)
+          Puppet::Util::POSIX.groups_of(user)
+        end
+      end
+
+      context 'number of groups' do
+        before(:each) do
+          stub_const("Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS", 2)
+          prepare_user_and_groups_env(user, expected_groups)
+
+          allow(FFI::MemoryPointer).to receive(:new).with(:uint, Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS).and_yield(groups_ptr)
+          allow(ngroups_ptr).to receive(:write_int).with(Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS).and_return(ngroups_ptr)
+        end
+
+        describe 'when there are less than maximum expected number of groups' do
+          let(:user) { 'root' }
+          let(:expected_groups) { ['root'] }
+
+          before(:each) do
+            allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist, any_args).and_return(true)
+            allow(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).and_return(1)
+          end
+
+          it "should return the groups for given user, after one 'getgrouplist' call" do
+            expect(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).once
+            expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+          end
+
+          it 'should not print any debug message about falling back to Puppet::Etc.group' do
+            expect(Puppet).not_to receive(:debug).with(/Falling back to Puppet::Etc.group:/)
+            Puppet::Util::POSIX.groups_of(user)
+          end
+        end
+
+        describe 'when there are more than maximum expected number of groups' do
+          let(:user) { 'user1' }
+          let(:expected_groups) { ['group1', 'group3'] }
+
+          before(:each) do
+            allow(FFI::MemoryPointer).to receive(:new).with(:uint, Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS * 2).and_yield(groups_ptr)
+            allow(ngroups_ptr).to receive(:write_int).with(Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS * 2).and_return(ngroups_ptr)
+
+            allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist, any_args).and_return(true)
+            allow(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).and_return(-1, 1)
+          end
+
+          it "should return the groups for given user, after two 'getgrouplist' calls" do
+            expect(Puppet::FFI::POSIX::Functions).to receive(:getgrouplist).twice
+            expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+          end
+
+          it 'should not print any debug message about falling back to Puppet::Etc.group' do
+            expect(Puppet).not_to receive(:debug).with(/Falling back to Puppet::Etc.group:/)
+            Puppet::Util::POSIX.groups_of(user)
+          end
+        end
+      end
+    end
+
+    describe 'when it falls back to Puppet::Etc.group method' do
+      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
+
+        allow(Puppet::Etc).to receive(:getpwnam).with(user).and_raise(ArgumentError, "can't find user for #{user}")
+        allow(Puppet).to receive(:debug)
+
+        allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist, any_args).and_return(false)
+      end
+
+      describe 'when there are groups' do
+        context 'for user1' do
+          let(:user) { 'user1' }
+          let(:expected_groups) { ['group1', 'group3'] }
+
+          it "should return the groups for given user" do
+            expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+          end
+
+          it 'logs a debug message' do
+            expect(Puppet).to receive(:debug).with("Falling back to Puppet::Etc.group: The 'getgrouplist' method is not available")
+            Puppet::Util::POSIX.groups_of(user)
+          end
+        end
+
+        context 'for user2' do
+          let(:user) { 'user2' }
+          let(:expected_groups) { ['group1', 'group2', 'group4'] }
+
+          it "should return the groups for given user" do
+            expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+          end
+
+          it 'logs a debug message' do
+            expect(Puppet).to receive(:debug).with("Falling back to Puppet::Etc.group: The 'getgrouplist' method is not available")
+            Puppet::Util::POSIX.groups_of(user)
+          end
+        end
+      end
+
+      describe 'when there are no groups' do
+        let(:user) { 'nomembers' }
+        let(:expected_groups) { [] }
+
+        it "should return no groups for given user" do
+          expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+        end
+
+        it 'logs a debug message' do
+          expect(Puppet).to receive(:debug).with("Falling back to Puppet::Etc.group: The 'getgrouplist' method is not available")
+          Puppet::Util::POSIX.groups_of(user)
+        end
+      end
+
+      describe 'when primary group explicitly contains user' do
+        let(:user) { 'root' }
+        let(:expected_groups) { ['root'] }
+
+        it "should return the groups, including primary group, for given user" do
+          expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+        end
+
+        it 'logs a debug message' do
+          expect(Puppet).to receive(:debug).with("Falling back to Puppet::Etc.group: The 'getgrouplist' method is not available")
+          Puppet::Util::POSIX.groups_of(user)
+        end
+      end
+
+      describe 'when primary group does not explicitly contain user' do
+        let(:user) { 'user1' }
+        let(:expected_groups) { ['group1', 'group3'] }
+
+        it "should not return primary group for given user" do
+          expect(Puppet::Util::POSIX.groups_of(user)).not_to include(user)
+        end
+
+        it 'logs a debug message' do
+          expect(Puppet).to receive(:debug).with("Falling back to Puppet::Etc.group: The 'getgrouplist' method is not available")
+          Puppet::Util::POSIX.groups_of(user)
+        end
+      end
+
+      describe "when the 'getgrouplist' method is not available" do
+        let(:user) { 'user1' }
+        let(:expected_groups) { ['group1', 'group3'] }
+
+        before(:each) do
+          allow(Puppet::FFI::POSIX::Functions).to receive(:respond_to?).with(:getgrouplist).and_return(false)
+        end
+
+        it "should return the groups" do
+          expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+        end
+
+        it 'logs a debug message' do
+          expect(Puppet).to receive(:debug).with("Falling back to Puppet::Etc.group: The 'getgrouplist' method is not available")
+          Puppet::Util::POSIX.groups_of(user)
+        end
+      end
+
+
+      describe "when ffi is not available on the machine" do
+        let(:user) { 'user1' }
+        let(:expected_groups) { ['group1', 'group3'] }
+
+        before(:each) do
+          allow(Puppet::Util::POSIX).to receive(:require).with('puppet/ffi/posix').and_raise(LoadError, 'cannot load such file -- ffi')
+        end
+
+        it "should return the groups" do
+          expect(Puppet::Util::POSIX.groups_of(user)).to eql(expected_groups)
+        end
+
+        it 'logs a debug message' do
+          expect(Puppet).to receive(:debug).with("Falling back to Puppet::Etc.group: cannot load such file -- ffi")
+          Puppet::Util::POSIX.groups_of(user)
+        end
+      end
+    end
+  end
+
   [:group, :gr].each do |name|
     it "should return :gid as the field for #{name}" do
       expect(@posix.idfield(name)).to eq(:gid)
@@ -42,7 +383,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
@@ -52,23 +393,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
@@ -76,17 +417,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
@@ -95,32 +436,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
@@ -128,10 +469,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
@@ -139,30 +480,49 @@ 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 "returns the id without full groups query if multiple groups have the same id" 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")
+        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "boo").and_return(100)
+
+        expect(@posix).not_to receive(:search_posix_field)
+        expect(@posix.gid("asdf")).to eq(100)
+      end
+
+      it "returns the id with full groups query if name is nil" 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(nil)
+        expect(@posix).not_to receive(:get_posix_field).with(:group, :gid, nil)
+
+
+        expect(@posix).to receive(:search_posix_field).with(:group, :gid, "asdf").and_return(100)
+        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
@@ -171,32 +531,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
@@ -204,10 +564,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
@@ -215,30 +575,49 @@ 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 "returns the id without full users query if multiple users have the same id" 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")
+        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "boo").and_return(100)
+
+        expect(@posix).not_to receive(:search_posix_field)
+        expect(@posix.uid("asdf")).to eq(100)
+      end
+
+      it "returns the id with full users query if name is nil" 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(nil)
+        expect(@posix).not_to receive(:get_posix_field).with(:passwd, :uid, nil)
+
 
+        expect(@posix).to receive(:search_posix_field).with(:passwd, :uid, "asdf").and_return(100)
         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

data/spec/unit/util/profiler/object_counts_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 require 'puppet/util/profiler'
 
-describe Puppet::Util::Profiler::ObjectCounts do
+describe Puppet::Util::Profiler::ObjectCounts, unless: Puppet::Util::Platform.jruby? do
+  # ObjectSpace is not enabled by default on JRuby
   it "reports the changes in the system object counts" do
     profiler = Puppet::Util::Profiler::ObjectCounts.new(nil, nil)