puppet 6.0.0 → 6.0.1

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

@@ -264,6 +264,101 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet::Util::Platform.windows? do
           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::Util::Platform.windows? do
           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::Util::Platform.windows? do
 
           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::Util::Platform.windows? do
           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::Util::Platform.windows? do
           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

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

@@ -52,6 +52,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
     pointer.stubs(:read_dword)
     pointer.stubs(:write_dword)
     pointer.stubs(:size)
+    subject.stubs(:sleep)
   end
 
   describe "#start" do
@@ -76,12 +77,13 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
       end
 
       it "Starts the service once the service reports SERVICE_RUNNING" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
         subject.start(mock_service_name)
       end
 
-      it "Raises an error if after calling StartServiceW the service is not in RUNNING or START_PENDING" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_PAUSED})
+      it "Raises an error if after calling StartServiceW the service never transitions to RUNNING or START_PENDING" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_PAUSED}).times(31)
         expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
       end
 
@@ -93,26 +95,32 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
 
     context "when the service hasn't stopped yet:" do
       it "waits, then queries again until SERVICE_STOPPED" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
         subject.expects(:sleep).with(3).twice
         subject.start(mock_service_name)
       end
 
       it "waits for at least 1 second if wait hint/10 is < 1 second" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
         subject.expects(:sleep).with(1)
         subject.start(mock_service_name)
       end
 
       it "waits for at most 10 seconds if wait hint/10 is > 10 seconds" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 1000000, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
         subject.expects(:sleep).with(10)
         subject.start(mock_service_name)
       end
@@ -123,20 +131,8 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
         expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
       end
 
-      it "raises a puppet error if the services configured dwWaitHint is 0, 30 seconds have passed and dwCheckPoint hasn't increased" do
-        # the number of times here is a little strange: there are 31 and 32 status queries sleeps because:
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0}).times(31)
-        subject.expects(:sleep).times(30).with(1)
-        expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
-      end
-
-      it "raises a puppet error if the services configured dwWaitHint has passed and dwCheckPoint hasn't increased" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 40000, :dwCheckPoint => 0}).times(11)
-        subject.expects(:sleep).times(10).with(4)
-        expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
-      end
-
       it "Does not raise an error if the service makes progress" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 2})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 30})
@@ -144,46 +140,84 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 98})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
-        subject.expects(:sleep).times(5).with(1)
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
         expect{subject.start(mock_service_name)}.to_not raise_error
       end
     end
 
+    context "when the service ends up still in STOPPED:" do
+      it "waits, then queries again until RUNNING" do
+        # these will be before the call to controlService
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        # everything from here on will be _after_ the call to ControlService
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.start(mock_service_name)
+      end
+
+      it "raises a puppet error if the services never exits the RUNNING state" do
+        # these will be before the call to controlService
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        # the number of times here is a little strange: there are 31 status queries sleeps because there will be a 31st query
+        # that is the final query where the command has reached the wait hint and it's time to error
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED}).times(31)
+        subject.expects(:sleep).times(30).with(1)
+        expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
+      end
+    end
+
     context "when the service ends up in START_PENDING:" do
-      it "waits, then queries again until SERVICE_RUNNING" do
+      before(:each) do
+        # these will be before the call to StartService
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+      end
+
+      it "waits, then queries again until SERVICE_RUNNING" do
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
-        subject.expects(:sleep).with(3).twice
         subject.start(mock_service_name)
       end
 
       it "waits for at least 1 second if wait hint/10 is < 1 second" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 1})
+        # the first call is executed in wait_for_state, which we aren't testing here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 2})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
         subject.expects(:sleep).with(1)
         subject.start(mock_service_name)
       end
 
       it "waits for at most 10 seconds if wait hint/10 is > 10 seconds" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        # the first call is executed in wait_for_state, which we aren't testing here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 1000000, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
         subject.expects(:sleep).with(10)
         subject.start(mock_service_name)
       end
 
+      it "raises a puppet error if the services configured dwWaitHint is 0, 30 seconds have passed and dwCheckPoint hasn't increased" do
+        # the first call is executed in wait_for_state, which we aren't testing here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0}).times(31)
+        subject.expects(:sleep).times(30).with(1)
+        expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
+      end
+
       it "raises a puppet error if the service's configured dwWaitHint has passed and dwCheckPoint hasn't increased" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        # the first call is executed in wait_for_state, which we aren't testing here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 40000, :dwCheckPoint => 0}).times(11)
         subject.expects(:sleep).times(10).with(4)
         expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
       end
 
       it "Does not raise an error if the service makes progress" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        # the first call is executed in wait_for_state, which we aren't testing here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 2})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 30})
@@ -213,48 +247,71 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
 
     context "when the service can be opened and is in the running state:" do
       before do
+        # this will be before the call to controlService
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
       end
-
-      it "Sends the SERVICE_CONTROL_STOP to the service once the service reports SERVICE_RUNNING" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
-        subject.stop(mock_service_name)
-      end
-
-      it "Raises an error if after calling ControlService the service is not in STOPPED or STOP_PENDING" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_PAUSED})
-        expect{ subject.stop(mock_service_name) }.to raise_error(Puppet::Error)
-      end
-
       it "raises a puppet error if ControlService returns false" do
         subject.expects(:ControlService).returns(FFI::WIN32_FALSE)
         expect{ subject.stop(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
 
-    # No need to retest much of the wait functionality here, since
+    # No need to retest the wait hint functionality itself here, since
     # both stop and start use the wait_for_pending_transition helper
     # which is tested in the start unit tests.
-    context "when the service hasn't started yet:" do
-      it "waits, then queries again until SERVICE_STOPPED" do
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
-        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+    context "when the service is already in stop pending or stopped" do
+      it "waits for the service to stop and then exits immediately" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 5})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
-        subject.expects(:sleep).with(3).twice
         subject.stop(mock_service_name)
       end
     end
 
     context "when the service ends up in STOP_PENDING:" do
-      it "waits, then queries again until SERVICE_RUNNING" do
+      before(:each) do
+        # this will be before the call to controlService
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+      end
+
+      it "waits, then queries again until SERVICE_STOPPED" do
+        # the first call is to wait_for_state, which we don't test here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING})
+        # everything from here on will be _after_ the call to ControlService
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
         expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
-        subject.expects(:sleep).with(3).twice
         subject.stop(mock_service_name)
       end
+
+      it "raises a puppet error if the services never exits the STOP_PENDING state" do
+        # the first call is to wait_for_state, which we don't test here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0}).times(31)
+        expect{subject.stop(mock_service_name)}.to raise_error(Puppet::Error)
+      end
+    end
+
+    context "when the service ends up still in RUNNING:" do
+      before(:each) do
+        # this will be before the call to controlService
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+      end
+      it "waits, then queries again until SERVICE_STOPPED" do
+        # the first call is to wait_for_state, which we don't test here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING, :dwWaitHint => 0, :dwCheckPoint => 0}).times(10)
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        subject.stop(mock_service_name)
+      end
+
+      it "raises a puppet error if the services never exits the RUNNING state" do
+        # the first call is to wait_for_state, which we don't test here
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING, :dwWaitHint => 0, :dwCheckPoint => 0}).times(31)
+        subject.expects(:sleep).times(30).with(1)
+        expect{subject.stop(mock_service_name)}.to raise_error(Puppet::Error)
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.0.1
 platform: ruby
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-18 00:00:00.000000000 Z
+date: 2018-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter