puppet 6.29.0-universal-darwin → 7.0.0-universal-darwin

data/spec/unit/util/inifile_spec.rb

@@ -443,9 +443,13 @@ describe Puppet::Util::IniConfig::FileCollection do
     end
 
     it "yields every section from every file" do
-      expect { |b|
-        subject.each_section(&b)
-      }.to yield_successive_args(sect_a1, sect_a2, sect_b1, sect_b2)
+      [sect_a1, sect_a2, sect_b1, sect_b2].each do |sect|
+        expect(sect).to receive(:touch).once
+      end
+
+      subject.each_section do |sect|
+        sect.touch
+      end
     end
   end
 
@@ -456,9 +460,13 @@ describe Puppet::Util::IniConfig::FileCollection do
     end
 
     it "yields the path to every file in the collection" do
-      expect { |b|
-        subject.each_file(&b)
-      }.to yield_successive_args(path_a, path_b)
+      seen = []
+      subject.each_file do |file|
+        seen << file
+      end
+
+      expect(seen).to include(path_a)
+      expect(seen).to include(path_b)
     end
   end
 

data/spec/unit/util/log_spec.rb

@@ -111,20 +111,16 @@ describe Puppet::Util::Log do
     end
 
     it "should fall back to :eventlog" do
-      without_partial_double_verification do
-        allow(Puppet.features).to receive(:syslog?).and_return(false)
-        allow(Puppet.features).to receive(:eventlog?).and_return(true)
-      end
+      allow(Puppet.features).to receive(:syslog?).and_return(false)
+      allow(Puppet.features).to receive(:eventlog?).and_return(true)
       expect(Puppet::Util::Log).to receive(:newdestination).with(:eventlog)
 
       Puppet::Util::Log.setup_default
     end
 
     it "should fall back to :file" do
-      without_partial_double_verification do
-        allow(Puppet.features).to receive(:syslog?).and_return(false)
-        allow(Puppet.features).to receive(:eventlog?).and_return(false)
-      end
+      allow(Puppet.features).to receive(:syslog?).and_return(false)
+      allow(Puppet.features).to receive(:eventlog?).and_return(false)
       expect(Puppet::Util::Log).to receive(:newdestination).with(Puppet[:puppetdlog])
 
       Puppet::Util::Log.setup_default
@@ -228,6 +224,9 @@ describe Puppet::Util::Log do
   describe Puppet::Util::Log::DestEventlog, :if => Puppet.features.eventlog? do
     before :each do
       allow(Puppet::Util::Windows::EventLog).to receive(:open).and_return(double('mylog', :close => nil))
+      allow(Puppet::Util::Windows::EventLog).to receive(:report_event)
+      allow(Puppet::Util::Windows::EventLog).to receive(:close)
+      allow(Puppet.features).to receive(:eventlog?).and_return(true)
     end
 
     it "should restrict its suitability to Windows" do

data/spec/unit/util/logging_spec.rb

@@ -552,8 +552,7 @@ original
 
     describe 'does support debugging' do
       before :each do
-        allow(Facter).to receive(:respond_to?).with(:on_message).and_return(true)
-        allow(Facter).to receive(:respond_to?).with(:debugging, any_args).and_return(true)
+        allow(Facter).to receive(:respond_to?).with(:debugging).and_return(true)
       end
 
       it 'enables Facter debugging when debug level' do
@@ -569,8 +568,7 @@ original
 
     describe 'does support trace' do
       before :each do
-        allow(Facter).to receive(:respond_to?).with(:on_message)
-        allow(Facter).to receive(:respond_to?).with(:trace, any_args).and_return(true)
+        allow(Facter).to receive(:respond_to?).with(:trace).and_return(true)
       end
 
       it 'enables Facter trace when enabled' do
@@ -586,7 +584,7 @@ original
 
     describe 'does support on_message' do
       before :each do
-        allow(Facter).to receive(:respond_to?).with(:on_message, any_args).and_return(true)
+        allow(Facter).to receive(:respond_to?).with(:on_message).and_return(true)
       end
 
       def setup(level, message)

data/spec/unit/util/monkey_patches_spec.rb

@@ -135,9 +135,3 @@ describe SecureRandom do
     expect(SecureRandom.uuid).to match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)
   end
 end
-
-describe 'Enumerable' do
-  it 'expects uniq to work on an Enumerable' do
-    expect(['c', 'c', 'C'].reverse_each.uniq).to eql(['C', 'c'])
-  end
-end

data/spec/unit/util/posix_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-require 'puppet/ffi/posix'
 require 'puppet/util/posix'
 
 class PosixTest
@@ -12,344 +11,35 @@ 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) }
-
+  describe '.groups_of' do
     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)|
+        ['group1', ['user1', 'user2']],
+        ['group2', ['user2']],
+        ['group1', ['user1', 'user2']],
+        ['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)
-        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
+      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
 
-    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
+    it 'returns the groups of the given user' do
+      expect(Puppet::Util::POSIX.groups_of('user1')).to eql(
+        ['group1', 'group3']
+      )
     end
   end
 
@@ -499,25 +189,6 @@ describe Puppet::Util::POSIX do
         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
         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")
@@ -594,25 +265,6 @@ describe Puppet::Util::POSIX do
         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
         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")