puppet 6.16.0-x86-mingw32 → 7.0.0-x86-mingw32

data/spec/unit/provider/service/src_spec.rb

@@ -1,13 +1,11 @@
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Src',
-         unless: Puppet::Util::Platform.jruby? do
+         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:src) }
 
-  if Puppet::Util::Platform.windows?
-    # Get a pid for $CHILD_STATUS to latch on to
-    command = "cmd.exe /c \"exit 0\""
-    Puppet::Util::Execution.execute(command, {:failonfail => false})
+  before :all do
+    `exit 0`
   end
 
   before :each do

data/spec/unit/provider/service/systemd_spec.rb

@@ -1,12 +1,9 @@
 require 'spec_helper'
 
-describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platform.jruby? do
+describe 'Puppet::Type::Service::Provider::Systemd',
+         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
+
   let(:provider_class) { Puppet::Type.type(:service).provider(:systemd) }
-  if Puppet::Util::Platform.windows?
-    # Get a pid for $CHILD_STATUS to latch on to
-    command = "cmd.exe /c \"exit 0\""
-    Puppet::Util::Execution.execute(command, {:failonfail => false})
-  end
 
   before :each do
     allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)

data/spec/unit/provider/service/upstart_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
-describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platform.jruby? do
+describe 'Puppet::Type::Service::Provider::Upstart',
+         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:manual) { "\nmanual" }
   let(:start_on_default_runlevels) {  "\nstart on runlevel [2,3,4,5]" }
   let!(:provider_class) { Puppet::Type.type(:service).provider(:upstart) }
 
-  if Puppet::Util::Platform.windows?
-    # Get a pid for $CHILD_STATUS to latch on to
-    command = "cmd.exe /c \"exit 0\""
-    Puppet::Util::Execution.execute(command, {:failonfail => false})
+  before :each do
+    `exit 0`
   end
 
   def given_contents_of(file, content)

data/spec/unit/provider/service/windows_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'win32/service' if Puppet::Util::Platform.windows?
 
 describe 'Puppet::Type::Service::Provider::Windows',
     :if => Puppet::Util::Platform.windows? && !Puppet::Util::Platform.jruby? do
@@ -58,7 +57,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       it "should enable if managing enable and enable is true" do
         resource[:enable] = :true
         expect(service_util).to receive(:start)
-        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+        expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START})
 
         provider.start
       end
@@ -66,7 +65,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       it "should manual start if managing enable and enable is false" do
         resource[:enable] = :false
         expect(service_util).to receive(:start)
-        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+        expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DEMAND_START})
 
         provider.start
       end
@@ -88,6 +87,14 @@ describe 'Puppet::Type::Service::Provider::Windows',
       expect(provider.status).to eql(:stopped)
     end
 
+    it "should report service as stopped when status cannot be retrieved" do
+      allow(service_util).to receive(:exists?).with(resource[:name]).and_return(true)
+      allow(service_util).to receive(:service_state).with(name).and_raise(Puppet::Error.new('Service query failed: The specified path is invalid.'))
+
+      expect(Puppet).to receive(:warning).with("Status for service #{resource[:name]} could not be retrieved: Service query failed: The specified path is invalid.")
+      expect(provider.status).to eql(:stopped)
+    end
+
     [
       :SERVICE_PAUSED,
       :SERVICE_PAUSE_PENDING
@@ -119,6 +126,34 @@ describe 'Puppet::Type::Service::Provider::Windows',
         expect(provider.status).to eq(:running)
       end
     end
+
+    context 'when querying lmhosts', if: Puppet::Util::Platform.windows? do
+      # This service should be ubiquitous across all supported Windows platforms
+      let(:service) { Puppet::Type.type(:service).new(:name => 'lmhosts') }
+
+      before :each do
+        allow(service_util).to receive(:exists?).with(service.name).and_call_original
+      end
+
+      it "reports if the service is enabled" do
+        expect([:true, :false, :manual]).to include(service.provider.enabled?)
+      end
+
+      it "reports on the service status" do
+        expect(
+          [
+            :running,
+            :'continue pending',
+            :'pause pending',
+            :paused,
+            :running,
+            :'start pending',
+            :'stop pending',
+            :stopped
+          ]
+        ).to include(service.provider.status)
+      end
+    end
   end
 
   describe "#restart" do
@@ -178,12 +213,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#enable" do
     it "should set service start type to Service_Auto_Start when enabled" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START})
       provider.enable
     end
 
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START).and_raise(Puppet::Error.new('foobar'))
+    it "raises an error if set_startup_configuration fails" do
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START}).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.enable
@@ -193,12 +228,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#disable" do
     it "should set service start type to Service_Disabled when disabled" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED)
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DISABLED})
       provider.disable
     end
 
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED).and_raise(Puppet::Error.new('foobar'))
+    it "raises an error if set_startup_configuration fails" do
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DISABLED}).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.disable
@@ -208,12 +243,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#manual_start" do
     it "should set service start type to Service_Demand_Start (manual) when manual" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DEMAND_START})
       provider.manual_start
     end
 
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START).and_raise(Puppet::Error.new('foobar'))
+    it "raises an error if set_startup_configuration fails" do
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DEMAND_START}).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.manual_start
@@ -223,12 +258,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#delayed_start" do
     it "should set service start type to Service_Config_Delayed_Auto_Start (delayed) when delayed" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START, true)
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START, delayed: true})
       provider.delayed_start
     end
 
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START, true).and_raise(Puppet::Error.new('foobar'))
+    it "raises an error if set_startup_configuration fails" do
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START, delayed: true}).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.delayed_start

data/spec/unit/provider/user/openbsd_spec.rb

@@ -45,6 +45,7 @@ describe Puppet::Type.type(:user).provider(:openbsd) do
   describe "#addcmd" do
     it "should return an array with the full command and expiry as MM/DD/YY" do
       allow(Facter).to receive(:value).with(:osfamily).and_return('OpenBSD')
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
       resource[:expiry] = "1997-06-01"
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', 'June 01 1997', 'myuser'])
     end

data/spec/unit/provider/user/useradd_spec.rb

@@ -72,20 +72,24 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       provider.create
     end
 
-    it "should use -G to set groups" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('Not RedHat')
-      resource[:ensure] = :present
-      resource[:groups] = ['group1', 'group2']
-      expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', 'myuser'], kind_of(Hash))
-      provider.create
-    end
+    context "when setting groups" do
+      it "uses -G to set groups" do
+        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
+        resource[:ensure] = :present
+        resource[:groups] = ['group1', 'group2']
+        expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', 'myuser'], kind_of(Hash))
+        provider.create
+      end
 
-    it "should use -G to set groups without -M on RedHat" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
-      resource[:ensure] = :present
-      resource[:groups] = ['group1', 'group2']
-      expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', '-M', 'myuser'], kind_of(Hash))
-      provider.create
+      it "uses -G to set groups with -M on supported systems" do
+        allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
+        resource[:ensure] = :present
+        resource[:groups] = ['group1', 'group2']
+        expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', '-M', 'myuser'], kind_of(Hash))
+        provider.create
+      end
     end
 
     it "should add -o when allowdupe is enabled and the user is being created" do
@@ -429,15 +433,17 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       provider.delete
     end
 
-    it "should use -M flag if home is not managed and on Redhat" do
+    it "should use -M flag if home is not managed on a supported system" do
       allow(Facter).to receive(:value).with(:osfamily).and_return("RedHat")
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
       resource[:managehome] = :false
       expect(provider).to receive(:execute).with(include('-M'), kind_of(Hash))
       provider.create
     end
 
-    it "should not use -M flag if home is not managed and not on Redhat" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return("not RedHat")
+    it "should not use -M flag if home is not managed on an unsupported system" do
+      allow(Facter).to receive(:value).with(:osfamily).and_return("Suse")
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("11")
       resource[:managehome] = :false
       expect(provider).to receive(:execute).with(excluding('-M'), kind_of(Hash))
       provider.create

data/spec/unit/provider/user/windows_adsi_spec.rb

@@ -72,6 +72,88 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
     end
   end
 
+  describe "when setting roles" do
+    context "when role_membership => minimum" do
+      before :each do
+        resource[:role_membership] = :minimum
+      end
+
+      it "should set the given role when user has no roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('')
+
+        expect(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole1']).and_return(nil)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should set only the misssing role when user already has other roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1')
+
+        expect(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole2']).and_return(nil)
+        provider.roles = 'givenRole1,givenRole2'
+      end
+
+      it "should never remove any roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1')
+        allow(Puppet::Util::Windows::User).to receive(:set_rights).and_return(nil)
+
+        expect(Puppet::Util::Windows::User).not_to receive(:remove_rights)
+        provider.roles = 'givenRole1,givenRole2'
+      end
+    end
+
+    context "when role_membership => inclusive" do
+      before :each do
+        resource[:role_membership] = :inclusive
+      end
+
+      it "should remove the unwanted role" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1,givenRole2')
+
+        expect(Puppet::Util::Windows::User).to receive(:remove_rights).with('testuser', ['givenRole2']).and_return(nil)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should add the missing role and remove the unwanted one" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1,givenRole2')
+
+        expect(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole3']).and_return(nil)
+        expect(Puppet::Util::Windows::User).to receive(:remove_rights).with('testuser', ['givenRole2']).and_return(nil)
+        provider.roles = 'givenRole1,givenRole3'
+      end
+
+      it "should not set any roles when the user already has given role" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1,givenRole2')
+        allow(Puppet::Util::Windows::User).to receive(:remove_rights).with('testuser', ['givenRole2']).and_return(nil)
+
+        expect(Puppet::Util::Windows::User).not_to receive(:set_rights)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should set the given role when user has no roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('')
+
+        expect(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole1']).and_return(nil)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should not remove any roles when user has no roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('')
+        allow(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole1']).and_return(nil)
+
+        expect(Puppet::Util::Windows::User).not_to receive(:remove_rights)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should remove all roles when none given" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1,givenRole2')
+
+        expect(Puppet::Util::Windows::User).not_to receive(:set_rights)
+        expect(Puppet::Util::Windows::User).to receive(:remove_rights).with('testuser', ['givenRole1', 'givenRole2']).and_return(nil)
+        provider.roles = ''
+      end
+    end
+  end
+
   describe "#groups_insync?" do
     let(:group1) { double(:account => 'group1', :domain => '.', :sid => 'group1sid') }
     let(:group2) { double(:account => 'group2', :domain => '.', :sid => 'group2sid') }

data/spec/unit/provider_spec.rb

@@ -670,18 +670,6 @@ describe Puppet::Provider do
 
       provider.send(:execpipe, "a_command", true, block)
     end
-
-    it "delegates instance execfail to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
-
-      provider.new.send(:execfail, "a_command", "an exception to raise")
-    end
-
-    it "delegates class execfail to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
-
-      provider.send(:execfail, "a_command", "an exception to raise")
-    end
   end
 
   context "mk_resource_methods" do

data/spec/unit/puppet_pal_2pec.rb

@@ -708,6 +708,46 @@ describe 'Puppet Pal' do
         end
       end
 
+      context 'facts are supported such that' do
+        it 'they are obtained if they are not given' do
+          facts = Puppet::Node::Facts.new(Puppet[:certname], 'puppetversion' => Puppet.version)
+          Puppet::Node::Facts.indirection.save(facts)
+
+          testing_env_dir # creates the structure
+          result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath ) do |ctx|
+            ctx.with_script_compiler {|c| c.evaluate_string("$facts =~ Hash and $facts[puppetversion] == '#{Puppet.version}'") }
+          end
+          expect(result).to eq(true)
+        end
+
+        it 'can be given as a hash when creating the environment' do
+          testing_env_dir # creates the structure
+          result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: { 'myfact' => 42 }) do |ctx|
+            ctx.with_script_compiler {|c| c.evaluate_string("$facts =~ Hash and $facts[myfact] == 42") }
+          end
+          expect(result).to eq(true)
+        end
+
+        it 'can be overridden with a hash when creating a script compiler' do
+          testing_env_dir # creates the structure
+          result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: { 'myfact' => 42 }) do |ctx|
+            ctx.with_script_compiler(facts: { 'myfact' => 43 }) {|c| c.evaluate_string("$facts =~ Hash and $facts[myfact] == 43") }
+          end
+          expect(result).to eq(true)
+        end
+
+        it 'can be disabled with the :set_local_facts option' do
+          Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: { 'myfact' => 42}) do |ctx|
+            ctx.with_script_compiler(facts: { 'myfact' => 42 }, set_local_facts: false) do |compiler|
+              expect { compiler.evaluate_string('$facts') }.to raise_error(
+                Puppet::PreformattedError,
+                /Unknown variable: 'facts'/
+              )
+            end
+          end
+        end
+      end
+
       context 'supports tasks such that' do
         it '"task_signature" returns the signatures of a generic task' do
           result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do |ctx|

data/spec/unit/puppet_pal_catalog_spec.rb

@@ -69,6 +69,51 @@ describe 'Puppet Pal' do
         }.to raise_error(/manifest_file or code_string cannot be given when configured_by_env is true/)
       end
 
+      it 'shadows target variables that collide with plan variables' do
+        facts       = { 'var' => 'fact' }
+        target_vars = { 'var' => 'target' }
+
+        expect(Puppet).to receive(:warning).with(/Target variable \$var will be overridden by fact of the same name/)
+
+        result = Puppet::Pal.in_tmp_environment('pal_env', facts: {}) do |ctx|
+          ctx.with_catalog_compiler(facts: facts, target_variables: target_vars ) do |c|
+            c.evaluate_string('$var')
+          end
+        end
+
+        expect(result).to eq('fact')
+      end
+
+      it 'shadows target variables that collide with facts' do
+        plan_vars   = { 'var' => 'plan' }
+        target_vars = { 'var' => 'target' }
+
+        expect(Puppet).to receive(:warning).with(/Target variable \$var will be overridden by plan variable of the same name/)
+        
+        result = Puppet::Pal.in_tmp_environment('pal_env', facts: {}) do |ctx|
+          ctx.with_catalog_compiler(variables: plan_vars, target_variables: target_vars ) do |c|
+            c.evaluate_string('$var')
+          end
+        end
+
+        expect(result).to eq('plan')
+      end
+
+      it 'shadows plan variables that collide with facts' do
+        facts     = { 'var' => 'fact' }
+        plan_vars = { 'var' => 'plan' }
+
+        expect(Puppet).to receive(:warning).with(/Plan variable \$var will be overridden by fact of the same name/)
+        
+        result = Puppet::Pal.in_tmp_environment('pal_env', facts: {}) do |ctx|
+          ctx.with_catalog_compiler(facts: facts, variables: plan_vars ) do |c|
+            c.evaluate_string('$var')
+          end
+        end
+
+        expect(result).to eq('fact')
+      end
+
       context "evaluate_string method" do
         it 'evaluates code string in a given tmp environment' do
           result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do |ctx|