puppet 6.12.0-x64-mingw32 → 6.17.0-x64-mingw32

data/spec/unit/type/package_spec.rb

@@ -30,6 +30,10 @@ describe Puppet::Type.type(:package) do
     expect(Puppet::Type.type(:package).provider_feature(:versionable)).not_to be_nil
   end
 
+  it "should have a :supports_flavors feature" do
+    expect(Puppet::Type.type(:package).provider_feature(:supports_flavors)).not_to be_nil
+  end
+
   it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
     expect(Puppet::Type.type(:package).provider_feature(:package_settings).methods).to eq([:package_settings_insync?, :package_settings, :package_settings=])
   end
@@ -53,6 +57,10 @@ describe Puppet::Type.type(:package) do
     it "should have a package_settings property" do
       expect(Puppet::Type.type(:package).attrtype(:package_settings)).to eq(:property)
     end
+
+    it "should have a flavor property" do
+      expect(Puppet::Type.type(:package).attrtype(:flavor)).to eq(:property)
+    end
   end
 
   describe "when validating attribute values" do

data/spec/unit/type/service_spec.rb

@@ -145,6 +145,166 @@ describe test_title, "when validating attribute values" do
     end
   end
 
+  describe "the service logon credentials" do 
+    before do
+      provider_class_with_logon_credentials = Puppet::Type.type(:service).provide(:simple) do
+        has_features :manages_logon_credentials
+        def logonpassword=(value) end
+      end
+      allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class_with_logon_credentials)
+    end
+
+    describe "the 'logonaccount' property" do
+      it "should not be munged nor checked when not on Windows" do
+        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+        service = Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'NonWindowsUser')
+
+        expect { service }.not_to raise_error
+        expect(service[:logonaccount]).to eq('NonWindowsUser')
+      end
+
+      context "when on Windows", :if => Puppet::Util::Platform.windows? do
+        before do
+          allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return("myPC")
+          allow(Puppet::Util::Windows::User).to receive(:default_system_account?).and_return(true)
+        end
+
+        ['LocalSystem', '.\LocalSystem', 'myPC\LocalSystem', 'lOcALsysTem'].each do |user_input|
+          it "should succesfully munge #{user_input} to 'LocalSystem'" do
+            service = Puppet::Type.type(:service).new(:name => "yay", :logonaccount => user_input)
+
+            expect { service }.not_to raise_error
+            expect(service[:logonaccount]).to eq('LocalSystem')
+          end
+        end
+
+        it "should succesfully munge local account" do
+          allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(Puppet::Util::Windows::SID::Principal.new("myUser", nil, nil, "myPC", :SidTypeUser))
+          service = Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser')
+
+          expect { service }.not_to raise_error
+          expect(service[:logonaccount]).to eq('.\myUser')
+        end
+
+        it "should succesfully munge domain account" do
+          allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(Puppet::Util::Windows::SID::Principal.new("DomainUser", nil, nil, "myDomain", :SidTypeUser))
+          service = Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'DomainUser')
+
+          expect { service }.not_to raise_error
+          expect(service[:logonaccount]).to eq('myDomain\DomainUser')
+        end
+
+        it "should succesfully munge well known user" do
+          allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(Puppet::Util::Windows::SID::Principal.new("LOCAL SERVICE", nil, nil, "NT AUTHORITY", :SidTypeWellKnownGroup))
+          service = Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'LocalService')
+
+          expect { service }.not_to raise_error
+          expect(service[:logonaccount]).to eq('NT AUTHORITY\LOCAL SERVICE')
+        end
+
+        it "should succesfully munge a SID" do
+          allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(Puppet::Util::Windows::SID::Principal.new("NETWORK SERVICE", nil, nil, "NT AUTHORITY", :SidTypeUser))
+          service = Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'S-1-5-20')
+
+          expect { service }.not_to raise_error
+          expect(service[:logonaccount]).to eq('NT AUTHORITY\NETWORK SERVICE')
+        end
+
+        it "should fail when account is invalid" do
+          allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(nil)
+          expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'InvalidUser') }.to raise_error(Puppet::Error, /\"InvalidUser\" is not a valid account/)
+        end
+
+        it "should fail when sid type is not user or well known user" do
+          allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(Puppet::Util::Windows::SID::Principal.new("Administrators", nil, nil, "BUILTIN", :SidTypeAlias))
+          expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'Administrators') }.to raise_error(Puppet::Error, /\"Administrators\" is not a valid account/)
+        end
+      end
+    end
+
+    describe "the logonpassword parameter" do
+      it "should fail when logonaccount is not being managed as well" do
+        expect { Puppet::Type.type(:service).new(:name => "yay", :logonpassword => 'myPass') }.to raise_error(Puppet::Error, /The 'logonaccount' parameter is mandatory when setting 'logonpassword'./)
+      end
+
+      it "should default to empty string when only logonaccount is being managed" do
+        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+        service = Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser')
+
+        expect { service }.not_to raise_error
+        expect(service[:logonpassword]).to eq("")
+      end
+
+      it "should default to nil when not even logonaccount is being managed" do
+        service = Puppet::Type.type(:service).new(:name => "yay")
+        expect(service[:logonpassword]).to eq(nil)
+      end
+
+      it "should fail when logonpassword includes the ':' character" do
+        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+        expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser', :logonpassword => 'my:Pass') }.to raise_error(Puppet::Error, /Passwords cannot include ':'/)
+      end
+
+      it "should not further check the password against given account when not on Windows" do
+        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+        expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser', :logonpassword => 'myPass') }.not_to raise_error
+      end
+
+      context "when on Windows", :if => Puppet::Util::Platform.windows? do
+        before do
+          allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return("myPC")
+          allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(name_to_principal_result)
+        end
+
+        it "should pass validation when given account is 'LocalSystem'" do
+          allow(Puppet::Util::Windows::User).to receive(:localsystem?).with('LocalSystem').and_return(true)
+          allow(Puppet::Util::Windows::User).to receive(:default_system_account?).with('LocalSystem').and_return(false)
+
+          expect(Puppet::Util::Windows::SID).not_to receive(:name_to_principal)
+          expect(Puppet::Util::Windows::User).not_to receive(:password_is?)
+          expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'LocalSystem') }.not_to raise_error
+        end
+
+        ['LOCAL SERVICE', 'NETWORK SERVICE', 'SYSTEM'].each do |predefined_local_account|
+          describe "when given account is #{predefined_local_account}" do
+            let(:name_to_principal_result) do
+              Puppet::Util::Windows::SID::Principal.new(predefined_local_account, nil, nil, "NT AUTHORITY", :SidTypeUser)
+            end
+
+            it "should pass validation" do
+              allow(Puppet::Util::Windows::User).to receive(:localsystem?).with(predefined_local_account).and_return(false)
+              expect(Puppet::Util::Windows::User).to receive(:default_system_account?).with("NT AUTHORITY\\#{predefined_local_account}").and_return(true)
+
+              expect(Puppet::Util::Windows::User).not_to receive(:password_is?)
+              expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => predefined_local_account) }.not_to raise_error
+            end
+          end
+        end
+
+        let(:name_to_principal_result) do
+          Puppet::Util::Windows::SID::Principal.new("myUser", nil, nil, "myPC", :SidTypeUser)
+        end
+
+        describe "when given logonaccount is not a predefined local account" do
+          before do
+            allow(Puppet::Util::Windows::User).to receive(:localsystem?).with('myUser').and_return(false)
+            allow(Puppet::Util::Windows::User).to receive(:default_system_account?).with('.\\myUser').and_return(false)
+          end
+
+          it "should pass validation if password is proven correct" do
+            allow(Puppet::Util::Windows::User).to receive(:password_is?).with('myUser', 'myPass', '.').and_return(true)
+            expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser', :logonpassword => 'myPass') }.not_to raise_error
+          end
+
+          it "should not pass validation if password check fails" do
+            allow(Puppet::Util::Windows::User).to receive(:password_is?).with('myUser', 'myWrongPass', '.').and_return(false)
+            expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser', :logonpassword => 'myWrongPass') }.to raise_error(Puppet::Error, /The given password is invalid for user '.\\myUser'/)
+          end
+        end
+      end
+    end
+  end
+
   it "should support :true as a value to :hasstatus" do
     srv = Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
     expect(srv[:hasstatus]).to eq(:true)
@@ -284,20 +444,21 @@ describe test_title, "when changing the host" do
     @service.property(:enable).sync
   end
 
-  it "should always consider the enable state of a static service to be in sync" do
+  it "should let superclass implementation resolve insyncness when provider does not respond to the 'enabled_insync?' method" do
     allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    expect(@service.provider).to receive(:cached_enabled?).and_return('static')
-    @service[:enable] = false
-    expect(Puppet).to receive(:debug).with("Unable to enable or disable static service yay")
+    @service[:enable] = true
+    allow(@service.provider).to receive(:respond_to?).with(:enabled_insync?).and_return(false)
+
     expect(@service.property(:enable).insync?(:true)).to eq(true)
   end
 
-  it "should determine insyncness normally when the service is not static" do
+  it "insyncness should be resolved by provider instead of superclass implementation when provider responds to the 'enabled_insync?' method" do
     allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    expect(@service.provider).to receive(:cached_enabled?).and_return('true')
     @service[:enable] = true
-    expect(Puppet).not_to receive(:debug)
-    expect(@service.property(:enable).insync?(:true)).to eq(true)
+    allow(@service.provider).to receive(:respond_to?).with(:enabled_insync?).and_return(true)
+    allow(@service.provider).to receive(:enabled_insync?).and_return(false)
+
+    expect(@service.property(:enable).insync?(:true)).to eq(false)
   end
 
   it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
@@ -313,6 +474,22 @@ describe test_title, "when changing the host" do
 
     @service.property(:ensure).sync
   end
+
+  it "should sync the service's logonaccount state when changing the state of :ensure if :logonaccount is being managed" do
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+
+    @service[:ensure] = :stopped
+    @service[:logonaccount] = 'LocalSystem'
+
+    expect(@service.property(:logonaccount)).to receive(:retrieve).and_return("MyUser")
+    expect(@service.property(:logonaccount)).to receive(:insync?).and_return(false)
+    expect(@service.property(:logonaccount)).to receive(:sync)
+
+    allow(@service.provider).to receive(:stop)
+
+    @service.property(:ensure).sync
+  end
 end
 
 describe test_title, "when refreshing the service" do

data/spec/unit/type/user_spec.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# encoding: utf-8
 require 'spec_helper'
 
 describe Puppet::Type.type(:user) do
@@ -408,7 +408,6 @@ describe Puppet::Type.type(:user) do
       Puppet::Resource::Catalog.new :testing do |conf|
         [testuser, testrole].each { |resource| conf.add_resource resource }
       end
-      allow(Puppet::Type::User::ProviderDirectoryservice).to receive(:get_macosx_version_major).and_return("10.5")
 
       rel = testuser.autorequire[0]
       expect(rel.source.ref).to eq(testrole.ref)

data/spec/unit/type_spec.rb

@@ -1099,6 +1099,56 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
       expect { expect(type.instances).to eq([]) }.to_not raise_error
     end
 
+    context "with a composite namevar type" do
+      let :type do
+        Puppet::Type.newtype(:type_spec_fake_type) do
+          newparam(:name) do
+            isnamevar
+          end
+
+          newparam(:path) do
+            isnamevar
+          end
+
+          def self.title_patterns
+            [[%r{^(.*)@(.*)$}, [:name, :path]], [%r{^([^@]+)$}, [:name]]]
+          end
+
+          newproperty(:prop1) {}
+        end
+
+        Puppet::Type.type(:type_spec_fake_type)
+      end
+
+      before :each do
+        type.provide(:default) do
+          defaultfor :operatingsystem => Facter.value(:operatingsystem)
+          mk_resource_methods
+          class << self
+            attr_accessor :params
+          end
+
+          def title
+            "#{@property_hash[:name]}@#{@property_hash[:path]}"
+          end
+
+          def self.instance(name, path)
+            new(:name => name, :path => path, :ensure => :present)
+          end
+
+          def self.instances
+            @instances ||= params.collect { |param| instance(param.first.to_s, param.last.to_s) }
+          end
+
+          @params = [[:name_one, :path_one], [:name_two, :path_two]]
+        end
+      end
+
+      it "should return composite titles for the instances" do
+        expect(type.instances.map(&:title)).to eq(["name_one@path_one", "name_two@path_two"])
+      end
+    end
+
     context "with a default provider" do
       before :each do
         type.provide(:default) do

data/spec/unit/util/at_fork_spec.rb

@@ -5,6 +5,7 @@ describe 'Puppet::Util::AtFork' do
 
   before :each do
     Puppet::Util.class_exec do
+      remove_const(:AtFork) if defined?(Puppet::Util::AtFork)
       const_set(:AtFork, Module.new)
     end
   end
@@ -18,7 +19,7 @@ describe 'Puppet::Util::AtFork' do
   describe '.get_handler' do
     context 'when on Solaris' do
       before :each do
-        expect(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+        expect(Puppet::Util::Platform).to receive(:solaris?).and_return(true)
       end
 
       after :each do
@@ -113,7 +114,7 @@ describe 'Puppet::Util::AtFork' do
 
     context 'when NOT on Solaris' do
       before :each do
-        expect(Facter).to receive(:value).with(:operatingsystem).and_return(nil)
+        expect(Puppet::Util::Platform).to receive(:solaris?).and_return(false)
       end
 
       def stub_noop_handler(namespace_only = false)

data/spec/unit/util/autoload_spec.rb

@@ -23,10 +23,10 @@ describe Puppet::Util::Autoload do
 
     def with_libdir(libdir)
       begin
-        Puppet::Util::Autoload.instance_variable_set(:@initialized, false)
         old_loadpath = $LOAD_PATH.dup
         old_libdir = Puppet[:libdir]
         Puppet[:libdir] = libdir
+        $LOAD_PATH.unshift(libdir)
         yield
       ensure
         Puppet[:libdir] = old_libdir
@@ -83,6 +83,7 @@ describe Puppet::Util::Autoload do
 
       libdir = File.expand_path('/libdir1')
       Puppet[:vendormoduledir] = vendor_dir
+      Puppet.initialize_settings
 
       with_libdir(libdir) do
         expect(@autoload.class).to receive(:gem_directories).and_return(%w{/one /two})

data/spec/unit/util/checksums_spec.rb

@@ -65,6 +65,22 @@ describe Puppet::Util::Checksums do
     expect(@summer.sumtype("asdfasdfa")).to be_nil
   end
 
+  it "has a list of known checksum types" do
+    expect(@summer.known_checksum_types).to match_array(content_sums + file_only)
+  end
+
+  it "returns true if the checksum is valid" do
+    expect(@summer).to be_valid_checksum('sha1', 'fcc1715b22278a9dae322b0a34935f10d1608b9f')
+  end
+
+  it "returns false if the checksum is known but invalid" do
+    expect(@summer).to_not be_valid_checksum('sha1', 'wronglength')
+  end
+
+  it "returns false if the checksum type is unknown" do
+    expect(@summer).to_not be_valid_checksum('rot13', 'doesntmatter')
+  end
+
   {:md5 => Digest::MD5, :sha1 => Digest::SHA1, :sha256 => Digest::SHA256, :sha512 => Digest::SHA512, :sha384 => Digest::SHA384}.each do |sum, klass|
     describe("when using #{sum}") do
       it "should use #{klass} to calculate string checksums" do

data/spec/unit/util/log/destinations_spec.rb

@@ -44,41 +44,13 @@ describe Puppet::Util::Log.desttypes[:file] do
       end
     end
 
-    describe "on POSIX systems", :if => Puppet.features.posix? do
+    describe "on POSIX systems", :unless => Puppet::Util::Platform.windows? do
       describe "with a normal file" do
         let (:parent) { Pathname.new('/tmp') }
         let (:abspath) { '/tmp/log' }
         let (:relpath) { 'log' }
 
         it_behaves_like "file destination"
-
-        it "logs an error if it can't chown the file owner & group" do
-          allow(File).to receive(:exist?).with(parent).and_return(true)
-          expect(File).to receive(:exist?).with(Pathname.new(abspath)).and_return(false)
-          expect(FileUtils).to receive(:chown).with(Puppet[:user], Puppet[:group], abspath).and_raise(Errno::EPERM)
-          expect(Puppet.features).to receive(:root?).and_return(true)
-          expect(Puppet).to receive(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
-
-          @class.new(abspath)
-        end
-
-        it "doesn't attempt to chown when running as non-root" do
-          allow(File).to receive(:exist?).with(parent).and_return(true)
-          expect(File).to receive(:exist?).with(Pathname.new(abspath)).and_return(false)
-          expect(FileUtils).not_to receive(:chown).with(Puppet[:user], Puppet[:group], abspath)
-          expect(Puppet.features).to receive(:root?).and_return(false)
-
-          @class.new(abspath)
-        end
-
-        it "doesn't attempt to chown when file already exists" do
-          allow(File).to receive(:exist?).with(parent).and_return(true)
-          expect(File).to receive(:exist?).with(Pathname.new(abspath)).and_return(true)
-          expect(FileUtils).not_to receive(:chown).with(Puppet[:user], Puppet[:group], abspath)
-          expect(Puppet.features).to receive(:root?).and_return(true)
-
-          @class.new(abspath)
-        end
       end
 
       describe "with a JSON file" do

data/spec/unit/util/package/version/debian_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'puppet/util/package/version/debian'
+
+describe Puppet::Util::Package::Version::Debian do
+  context "when creating new version should fail" do
+    it "if is parsing symbols" do
+      expect { described_class.parse(:absent) }.to raise_error(described_class::ValidationFailure)
+    end
+  end
+  context "when creating new version" do
+    it "is parsing basic version" do
+      v = described_class.parse('1:20191210.1-0ubuntu0.19.04.2')
+      expect(v.epoch).to eql(1)
+      expect(v.upstream_version).to eql('20191210.1')
+      expect(v.debian_revision).to eql('0ubuntu0.19.04.2')
+    end
+
+    it "is parsing no epoch basic version" do
+      v = described_class.parse('20191210.1-0ubuntu0.19.04.2')
+      expect(v.epoch).to eql(0)
+      expect(v.upstream_version).to eql('20191210.1')
+      expect(v.debian_revision).to eql('0ubuntu0.19.04.2')
+    end
+
+    it "is parsing no debian revision basic version" do
+      v = described_class.parse('2.42.1+19.04')
+      expect(v.epoch).to eql(0)
+      expect(v.upstream_version).to eql('2.42.1+19.04')
+      expect(v.debian_revision).to eql(nil)
+    end
+
+    it "is parsing no epoch complex version" do
+      v = described_class.parse('3.32.2+git20190711-2ubuntu1~19.04.1')
+      expect(v.epoch).to eql(0)
+      expect(v.upstream_version).to eql('3.32.2+git20190711')
+      expect(v.debian_revision).to eql('2ubuntu1~19.04.1')
+    end
+
+    it "is parsing even more complex version" do
+      v = described_class.parse('5:1.0.0+git-20190109.133f4c4-0ubuntu2')
+      expect(v.epoch).to eql(5)
+      expect(v.upstream_version).to eql('1.0.0+git-20190109.133f4c4')
+      expect(v.debian_revision).to eql('0ubuntu2')
+    end
+  end
+  context "when comparing two versions" do
+    it "epoch has precedence" do
+      first = described_class.parse('9:99-99')
+      second = described_class.parse('10:01-01')
+      expect(first < second).to eql(true)
+    end
+    it "handles equals letters-only versions" do
+      lower = described_class.parse('abd-def')
+      higher = described_class.parse('abd-def')
+      expect(lower == higher).to eql(true)
+    end
+    it "shorter version is smaller" do
+      lower = described_class.parse('abd-de')
+      higher = described_class.parse('abd-def')
+      expect(lower < higher).to eql(true)
+    end
+    it "shorter version is smaller even with digits" do
+      lower = described_class.parse('a1b2d-d3e')
+      higher = described_class.parse('a1b2d-d3ef')
+      expect(lower < higher).to eql(true)
+    end
+    it "shorter version is smaller when number is less" do
+      lower = described_class.parse('a1b2d-d9')
+      higher = described_class.parse('a1b2d-d13')
+      expect(lower < higher).to eql(true)
+    end
+    it "handles ~ version" do
+      lower = described_class.parse('a1b2d-d10~')
+      higher = described_class.parse('a1b2d-d10')
+      expect(lower < higher).to eql(true)
+    end
+    it "handles letters versus -" do
+      lower = described_class.parse('a1b2d-d1a')
+      higher = described_class.parse('a1b2d-d1-')
+      expect(lower < higher).to eql(true)
+    end
+  end
+end