puppet 5.5.6 → 5.5.7

data/spec/unit/type/resources_spec.rb

@@ -92,6 +92,24 @@ describe resources do
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
         expect(res.user_check(user)).to be_falsey
       end
+
+      it "should not purge Windows system users" do
+        res = Puppet::Type.type(:resources).new :name => :user, :purge => true
+        res.catalog = Puppet::Resource::Catalog.new
+        user_hash = {:name => 'Administrator', :uid => 'S-1-5-21-12345-500'}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        expect(res.user_check(user)).to be_falsey
+      end
+
+      it "should not purge Windows system users" do
+        res = Puppet::Type.type(:resources).new :name => :user, :purge => true
+        res.catalog = Puppet::Resource::Catalog.new
+        user_hash = {:name => 'other', :uid => 'S-1-5-21-12345-1001'}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        expect(res.user_check(user)).to be_truthy
+      end
     end
 
     %w(FreeBSD OpenBSD).each do |os|

data/spec/unit/util/execution_spec.rb

@@ -119,6 +119,17 @@ describe Puppet::Util::Execution do
         call_exec_posix("/bin/echo 'foo' ; \n /bin/echo 'bar' ;", {:uid => 50, :gid => 55}, @stdin, @stdout, @stderr)
       end
 
+      context 'cwd option' do
+        let(:cwd) { 'cwd' }
+
+        it 'should run the command in the specified working directory' do
+          Dir.expects(:chdir).with(cwd)
+          Kernel.expects(:exec).with('test command')
+
+          call_exec_posix('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)
+        end
+      end
+
       it "should return the pid of the child process" do
         expect(call_exec_posix('test command', {}, @stdin, @stdout, @stderr)).to eq(pid)
       end
@@ -144,6 +155,42 @@ describe Puppet::Util::Execution do
         call_exec_windows('test command', {}, @stdin, @stdout, @stderr)
       end
 
+      context 'cwd option' do
+        let(:cwd) { 'cwd' }
+        it "should execute the command in the specified working directory" do
+          Dir.expects(:chdir).with(cwd).yields
+          Process.expects(:create).with(
+            :command_line => "test command",
+            :startup_info => {
+              :stdin => @stdin,
+              :stdout => @stdout,
+              :stderr => @stderr
+            },
+            :close_handles => false
+          )
+
+          call_exec_windows('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)
+        end
+      end
+
+      context 'suppress_window option' do
+        let(:cwd) { 'cwd' }
+        it "should execute the command in the specified working directory" do
+          Process.expects(:create).with(
+            :command_line => "test command",
+            :startup_info => {
+              :stdin => @stdin,
+              :stdout => @stdout,
+              :stderr => @stderr
+            },
+            :close_handles => false,
+            :creation_flags => Puppet::Util::Windows::Process::CREATE_NO_WINDOW
+          )
+
+          call_exec_windows('test command', { :suppress_window => true }, @stdin, @stdout, @stderr)
+        end
+      end
+
       it "should return the process info of the child process" do
         expect(call_exec_windows('test command', {}, @stdin, @stdout, @stderr)).to eq(proc_info_stub)
       end
@@ -219,6 +266,36 @@ describe Puppet::Util::Execution do
           end
         end
 
+        describe "cwd option" do
+          def expect_cwd_to_be(cwd)
+            Puppet::Util::Execution.expects(executor).with(
+              anything,
+              has_entries(:cwd => cwd),
+              anything,
+              anything,
+              anything
+            ).returns(rval)
+          end
+
+          it 'should raise an ArgumentError if the specified working directory does not exist' do
+            cwd = 'cwd'
+            Puppet::FileSystem.stubs(:directory?).with(cwd).returns(false)
+
+            expect {
+              Puppet::Util::Execution.execute('test command', cwd: cwd)
+            }.to raise_error do |error|
+              expect(error).to be_a(ArgumentError)
+              expect(error.message).to match(cwd)
+            end
+          end
+
+          it "should set the cwd to the user-specified one" do
+            Puppet::FileSystem.stubs(:directory?).with('cwd').returns(true)
+            expect_cwd_to_be('cwd')
+            Puppet::Util::Execution.execute('test command', cwd: 'cwd')
+          end
+        end
+
         describe "on POSIX", :if => Puppet.features.posix? do
           describe "when squelch is not set" do
             it "should set stdout to a pipe" do

data/spec/unit/util/posix_spec.rb

@@ -12,6 +12,34 @@ describe Puppet::Util::POSIX do
     @posix = PosixTest.new
   end
 
+  describe '.groups_of' do
+    let(:mock_groups) do
+      [
+        ['group1', ['user1', 'user2']],
+        ['group2', ['user2']],
+        ['group1', ['user1', 'user2']],
+        ['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
+      end
+    end
+
+    before(:each) do
+      Puppet::Etc.stubs(:group).multiple_yields(*mock_groups)
+    end
+
+    it 'returns the groups of the given user' do
+      expect(Puppet::Util::POSIX.groups_of('user1')).to eql(
+        ['group1', 'group3']
+      )
+    end
+  end
+
   [:group, :gr].each do |name|
     it "should return :gid as the field for #{name}" do
       expect(@posix.idfield(name)).to eq(:gid)

data/spec/unit/util/storage_spec.rb

@@ -213,5 +213,112 @@ describe Puppet::Util::Storage do
 
       expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
     end
+
+    it "expires entries with a :checked older than statettl seconds ago" do
+      Puppet[:statettl] = '1d'
+      recent_checked = Time.now
+      stale_checked = Time.now - (Puppet[:statettl] + 1)
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:stale)[:checked] = stale_checked
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :stale => {
+            :checked => stale_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          }
+        }
+      )
+    end
+
+
+    it "does not expire entries when statettl is 0" do
+      Puppet[:statettl] = '0'
+      recent_checked = Time.now
+      older_checked = Time.now - 10_000_000
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:older)[:checked] = older_checked
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+    end
+
+
+    it "does not expire entries when statettl is 'unlimited'" do
+      Puppet[:statettl] = 'unlimited'
+      recent_checked = Time.now
+      older_checked = Time.now - 10_000_000
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:older)[:checked] = older_checked
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+    end
   end
 end

data/spec/unit/util/windows/adsi_spec.rb

@@ -102,7 +102,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       user = Puppet::Util::Windows::ADSI::User.create(username)
 
       expect(user).to be_a(Puppet::Util::Windows::ADSI::User)
-      expect(user.native_user).to eq(adsi_user)
+      expect(user.native_object).to eq(adsi_user)
     end
 
     it "should be able to check the existence of a user" do
@@ -152,10 +152,10 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       wmi_users = [stub('WMI', :name => name)]
       Puppet::Util::Windows::ADSI.expects(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').returns(wmi_users)
 
-      native_user = stub('IADsUser')
+      native_object = stub('IADsUser')
       homedir = "C:\\Users\\#{name}"
-      native_user.expects(:Get).with('HomeDirectory').returns(homedir)
-      Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{name},user").returns(native_user)
+      native_object.expects(:Get).with('HomeDirectory').returns(homedir)
+      Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{name},user").returns(native_object)
 
       users = Puppet::Util::Windows::ADSI::User.to_a
       expect(users.length).to eq(1)
@@ -264,6 +264,101 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           end
         end
       end
+
+      describe 'userflags' do
+        # Avoid having to type out the constant everytime we want to
+        # retrieve a userflag's value.
+        def ads_userflags(flag)
+          Puppet::Util::Windows::ADSI::User::ADS_USERFLAGS[flag]
+        end
+
+        before(:each) do
+          userflags = [
+            :ADS_UF_SCRIPT,
+            :ADS_UF_ACCOUNTDISABLE,
+            :ADS_UF_HOMEDIR_REQUIRED,
+            :ADS_UF_LOCKOUT
+          ].inject(0) do |flags, flag|
+            flags | ads_userflags(flag)
+          end
+
+          user.stubs(:[]).with('UserFlags').returns(userflags)
+        end
+
+        describe '#userflag_set?' do
+          it 'returns true if the specified userflag is set' do
+            expect(user.userflag_set?(:ADS_UF_SCRIPT)).to be true
+          end
+
+          it 'returns false if the specified userflag is not set' do
+            expect(user.userflag_set?(:ADS_UF_PASSWD_NOTREQD)).to be false
+          end
+
+          it 'returns false if the specified userflag is an unrecognized userflag' do
+            expect(user.userflag_set?(:ADS_UF_UNRECOGNIZED_FLAG)).to be false
+          end
+        end
+
+        shared_examples 'set/unset common tests' do |method|
+          it 'raises an ArgumentError for any unrecognized userflags' do
+            unrecognized_flags = [
+              :ADS_UF_UNRECOGNIZED_FLAG_ONE,
+              :ADS_UF_UNRECOGNIZED_FLAG_TWO
+            ]
+            input_flags = unrecognized_flags + [
+              :ADS_UF_PASSWORD_EXPIRED,
+              :ADS_UF_DONT_EXPIRE_PASSWD
+            ]
+
+            expect { user.send(method, *input_flags) }.to raise_error(
+              ArgumentError, /#{unrecognized_flags.join(', ')}/
+            )
+          end
+
+          it 'noops if no userflags are passed-in' do
+            user.expects(:[]=).never
+            user.expects(:commit).never
+
+            user.send(method)
+          end
+        end
+
+        describe '#set_userflags' do
+          include_examples 'set/unset common tests', :set_userflags
+
+          it 'should add the passed-in flags to the current set of userflags' do
+            input_flags = [
+              :ADS_UF_PASSWORD_EXPIRED,
+              :ADS_UF_DONT_EXPIRE_PASSWD
+            ]
+
+            userflags = user['UserFlags']
+            expected_userflags = userflags | ads_userflags(input_flags[0]) | ads_userflags(input_flags[1])
+
+            user.expects(:[]=).with('UserFlags', expected_userflags)
+
+            user.set_userflags(*input_flags)
+          end
+        end
+
+        describe '#unset_userflags' do
+          include_examples 'set/unset common tests', :unset_userflags
+
+          it 'should remove the passed-in flags from the current set of userflags' do
+            input_flags = [
+              :ADS_UF_SCRIPT,
+              :ADS_UF_ACCOUNTDISABLE
+            ]
+
+            # ADS_UF_HOMEDIR_REQUIRED and ADS_UF_LOCKOUT should be the only flags set.
+            expected_userflags = 0 | ads_userflags(:ADS_UF_HOMEDIR_REQUIRED) | ads_userflags(:ADS_UF_LOCKOUT)
+
+            user.expects(:[]=).with('UserFlags', expected_userflags)
+
+            user.unset_userflags(*input_flags)
+          end
+        end
+      end
     end
   end
 
@@ -338,7 +433,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
           adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
 
-          group.set_members(['user2', 'DOMAIN2\user3'])
+          group.set_members('user2,DOMAIN2\user3')
         end
 
         it "should add the desired_members to an existing group when not inclusive" do
@@ -365,7 +460,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
           adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
 
-          group.set_members(['user2', 'DOMAIN2\user3'],false)
+          group.set_members('user2,DOMAIN2\user3',false)
         end
 
         it "should return immediately when desired_members is nil" do
@@ -397,7 +492,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
           adsi_group.expects(:Remove).with('WinNT://testcomputername/user2,user')
 
-          group.set_members([])
+          group.set_members('')
         end
 
         it "should do nothing when desired_members is empty and not inclusive" do
@@ -416,13 +511,13 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           adsi_group.expects(:Remove).never
           adsi_group.expects(:Add).never
 
-          group.set_members([],false)
+          group.set_members('',false)
         end
 
         it "should raise an error when a username does not resolve to a SID" do
           expect {
             adsi_group.expects(:Members).returns []
-            group.set_members(['foobar'])
+            group.set_members('foobar')
           }.to raise_error(Puppet::Error, /Could not resolve name: foobar/)
         end
       end
@@ -457,7 +552,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       group = Puppet::Util::Windows::ADSI::Group.create(groupname)
 
       expect(group).to be_a(Puppet::Util::Windows::ADSI::Group)
-      expect(group.native_group).to eq(adsi_group)
+      expect(group.native_object).to eq(adsi_group)
     end
 
     it "should be able to confirm the existence of a group" do
@@ -502,10 +597,10 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       wmi_groups = [stub('WMI', :name => name)]
       Puppet::Util::Windows::ADSI.expects(:execquery).with('select name from win32_group where localaccount = "TRUE"').returns(wmi_groups)
 
-      native_group = stub('IADsGroup')
+      native_object = stub('IADsGroup')
       Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([]).returns(stub(:domain_account => '.\Administrator'))
-      native_group.expects(:Members).returns([stub(:Name => 'Administrator', :objectSID => [], :ole_respond_to? => true)])
-      Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{name},group").returns(native_group)
+      native_object.expects(:Members).returns([stub(:Name => 'Administrator', :objectSID => [], :ole_respond_to? => true)])
+      Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{name},group").returns(native_object)
 
       groups = Puppet::Util::Windows::ADSI::Group.to_a
       expect(groups.length).to eq(1)