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

data/spec/unit/defaults_spec.rb

@@ -65,9 +65,9 @@ describe "Defaults" do
   end
 
   describe '.default_digest_algorithm' do
-    it 'defaults to md5 when FIPS is not enabled' do
+    it 'defaults to sha256 when FIPS is not enabled' do
       allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(false)
-      expect(Puppet.default_digest_algorithm).to eq('md5')
+      expect(Puppet.default_digest_algorithm).to eq('sha256')
     end
 
     it 'defaults to sha256 when FIPS is enabled' do
@@ -77,9 +77,9 @@ describe "Defaults" do
   end
 
   describe '.supported_checksum_types' do
-    it 'defaults to md5, sha256, sha384, sha512, sha224 when FIPS is not enabled' do
+    it 'defaults to sha256, sha384, sha512, sha224, md5 when FIPS is not enabled' do
       allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(false)
-      expect(Puppet.default_file_checksum_types).to eq(%w[md5 sha256 sha384 sha512 sha224])
+      expect(Puppet.default_file_checksum_types).to eq(%w[sha256 sha384 sha512 sha224 md5])
     end
 
     it 'defaults to sha256, sha384, sha512, sha224 when FIPS is enabled' do
@@ -89,8 +89,8 @@ describe "Defaults" do
   end
 
   describe 'Puppet[:supported_checksum_types]' do
-    it 'defaults to md5, sha256, sha512, sha384, sha224' do
-      expect(Puppet.settings[:supported_checksum_types]).to eq(%w[md5 sha256 sha384 sha512 sha224])
+    it 'defaults to sha256, sha512, sha384, sha224, md5' do
+      expect(Puppet.settings[:supported_checksum_types]).to eq(%w[sha256 sha384 sha512 sha224 md5])
     end
 
     it 'should raise an error on an unsupported checksum type' do
@@ -182,37 +182,86 @@ describe "Defaults" do
     end
   end
 
-  describe "facterng" do
-    it "defaults to false" do
-      expect(Puppet[:facterng]).to be_falsey
+  describe "deprecated settings" do
+    it 'does not issue a deprecation warning by default' do
+      expect(Puppet).to receive(:deprecation_warning).never
+
+      Puppet.initialize_settings
+    end
+  end
+
+  describe "the call hook for the cadir setting", unless: Puppet::Util::Platform.windows? do
+    it 'does not warn when the cadir is outside the puppet ssldir' do
+      FileUtils.mkdir_p(Puppet[:confdir])
+      # This is fun; in order to get the confdir setting from the spec_helper to
+      # not be deleted by the #unsafe_clear in Puppet::Settings#parse_config,
+      # we can code it into the confdir itself, and thus we can avoid getting
+      # that setting wiped out during Puppet.initialize_settings.
+      File.write(File.join(Puppet[:confdir], 'puppet.conf'),
+                 "cadir = /my/cool/path/for/my/cadir\n
+                  confdir = #{Puppet[:confdir]}")
+      expect(Puppet).to_not receive(:log_ca_migration_warning)
+      Puppet.initialize_settings
+      expect(Puppet[:cadir]).to eq("/my/cool/path/for/my/cadir")
     end
 
-    it "raises an exception if facter-ng could not be loaded" do
-      allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_raise(LoadError)
+    it 'does warn when the cadir is inside the puppet ssldir' do
+      FileUtils.mkdir_p(Puppet[:confdir])
+      cadir_location = File.join(Puppet[:ssldir], 'still_inside_ssldir')
+      # This is fun; in order to get the confdir setting from the spec_helper to
+      # not be deleted by the #unsafe_clear in Puppet::Settings#parse_config,
+      # we can code it into the confdir itself, and thus we can avoid getting
+      # that setting wiped out during Puppet.initialize_settings.
+      File.write(File.join(Puppet[:confdir], 'puppet.conf'),
+                 "cadir = #{cadir_location}\n
+                  confdir = #{Puppet[:confdir]}")
+      expect(Puppet).to receive(:log_ca_migration_warning).twice
+      Puppet.initialize_settings
+      expect(Puppet[:cadir]).to eq(cadir_location)
+      end
+  end
 
-      expect{ Puppet.settings[:facterng] = true }.to raise_exception ArgumentError, 'facter-ng could not be loaded'
+  describe "the default cadir", :unless => Puppet::Util::Platform.windows?  do
+    it 'defaults to the puppetserver confdir' do
+      Puppet.initialize_settings
+      expect(Puppet[:cadir]).to eq('/etc/puppetlabs/puppetserver/ca')
     end
 
-    context 'set logger' do
-      before do
-        @original_facter = Object.const_get(:Facter)
+    it 'returns an empty string for Windows platforms', :if => Puppet::Util::Platform.windows? do
+      Puppet.initialize_settings
+      expect(Puppet[:cadir]).to eq("")
+    end
+  end
 
-        Object.send(:remove_const, :Facter)
-        Object.const_set(:Facter, Module.new)
+  describe '#default_cadir', :unless => Puppet::Util::Platform.windows?  do
+    it 'returns the new puppetserver directory when no ca dir is present' do
+      expect(Puppet).to_not receive(:log_ca_migration_warning)
+      expect(Puppet.default_cadir).to eq('/etc/puppetlabs/puppetserver/ca')
+    end
 
-        allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_return(true)
-        allow(Facter).to receive(:respond_to?).and_return(false)
-      end
+    it 'warns when a CA dir exists in the current ssldir' do
+      cadir = File.join(Puppet[:ssldir], 'ca')
+      FileUtils.mkdir_p(cadir)
+      expect(Puppet).to receive(:log_ca_migration_warning)
+      expect(Puppet.default_cadir).to eq(cadir)
+    end
 
-      after do
-        Object.const_set(:Facter, @original_facter)
-      end
+    it 'warns when the cadir is a symlink still inside the ssldir' do
+      another_dir = File.join(Puppet[:ssldir], 'another_dir')
+      cadir = File.join(Puppet[:ssldir], 'ca')
+      FileUtils.mkdir_p(another_dir)
+      File.symlink(another_dir, cadir)
+      expect(Puppet).to receive(:log_ca_migration_warning)
+      expect(Puppet.default_cadir).to eq(another_dir)
+    end
 
-      it 'calls setup_facter_logging!' do
-        allow(Puppet::Util::Logging).to receive(:setup_facter_logging!).and_return(true)
-        Puppet.settings[:facterng] = true
-        expect(Puppet::Util::Logging).to have_received(:setup_facter_logging!).once
-      end
+    it 'does not warn when the cadir is a symlink targeted outside the ssldir' do
+      another_dir = Dir.mktmpdir
+      cadir = File.join(Puppet[:ssldir], 'ca')
+      FileUtils.mkdir_p(Puppet[:ssldir])
+      File.symlink(another_dir, cadir)
+      expect(Puppet).to_not receive(:log_ca_migration_warning)
+      expect(Puppet.default_cadir).to eq(another_dir)
     end
   end
 end

data/spec/unit/environments_spec.rb

@@ -436,25 +436,6 @@ config_version=$vardir/random/scripts
           end
         end
       end
-
-      context "custom cache expiration service" do
-        it "consults the custom service to expire the cache" do
-          loader_from(:filesystem => [directory_tree],
-                      :directory => directory_tree.children.first) do |loader|
-            service = ReplayExpirationService.new([true])
-            using_expiration_service(service) do
-
-              cached = Puppet::Environments::Cached.new(loader)
-              cached.get(:an_environment)
-              cached.get(:an_environment)
-
-              expect(service.created_envs).to include(:an_environment)
-              expect(service.expired_envs).to include(:an_environment)
-              expect(service.evicted_envs).to include(:an_environment)
-            end
-          end
-        end
-      end
     end
   end
 
@@ -645,6 +626,99 @@ config_version=$vardir/random/scripts
       end
     end
 
+    context "expiration policies" do
+      let(:service) { ReplayExpirationService.new }
+
+      # The environment named `:an_environment` will already be loaded when the
+      # block is yielded to
+      def with_environment_loaded(service, &block)
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+          using_expiration_service(service) do
+            cached = Puppet::Environments::Cached.new(loader)
+            cached.get!(:an_environment)
+
+            yield cached if block_given?
+          end
+        end
+      end
+
+      it "notifies when the environment is first created" do
+        with_environment_loaded(service)
+
+        expect(service.created_envs).to eq([:an_environment])
+      end
+
+      it "does not evict an unexpired environment" do
+        Puppet[:environment_timeout] = 'unlimited'
+
+        with_environment_loaded(service) do |cached|
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment])
+        expect(service.evicted_envs).to eq([])
+      end
+
+      it "evicts an expired environment" do
+        service = ReplayExpirationService.new
+
+        # The `Cached#clear_all_expired` method tries to optimize the case where
+        # no entries are expired. But if `Time.now < @next_expiration` and there is
+        # an expired entry, then the `service#expired?` method is called twice.
+        expect(service).to receive(:expired?).twice.and_return(true)
+
+        with_environment_loaded(service) do |cached|
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
+
+      it "evicts an environment that hasn't been recently touched" do
+        Puppet[:environment_timeout] = 1
+
+        with_environment_loaded(service) do |cached|
+          future = Time.now + 60
+          expect(Time).to receive(:now).and_return(future).at_least(:once)
+
+          # this should cause the cached environment to be evicted and a new one created
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+
+      end
+
+      it "reuses an environment that was recently touched" do
+        Puppet[:environment_timeout] = 60
+
+        with_environment_loaded(service) do |cached|
+          # reuse the already cached environment
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment])
+        expect(service.evicted_envs).to eq([])
+      end
+
+      it "evicts a recently touched environment" do
+        Puppet[:environment_timeout] = 60
+
+        # see note above about "twice"
+        expect(service).to receive(:expired?).twice.and_return(true)
+
+        with_environment_loaded(service) do |cached|
+          # even though the environment was recently touched, it's been expired
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
+    end
+
     it "gets an environment.conf" do
       loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
         expect(Puppet::Environments::Cached.new(loader).get_conf(:an_environment)).to match_environment_conf(:an_environment).
@@ -746,31 +820,21 @@ config_version=$vardir/random/scripts
     end
   end
 
-  class ReplayExpirationService
-    attr_reader :created_envs, :expired_envs, :evicted_envs
+  class ReplayExpirationService < Puppet::Environments::Cached::DefaultCacheExpirationService
+    attr_reader :created_envs, :evicted_envs
 
-    def initialize(expiration_sequence)
+    def initialize
       @created_envs = []
-      @expired_envs = []
       @evicted_envs = []
-      @expiration_sequence = expiration_sequence
     end
 
     def created(env)
       @created_envs << env.name
     end
 
-    def expired?(env_name)
-      # make expired? idempotent
-      return true if @expired_envs.include? (env_name)
-      @expired_envs << env_name
-      @expiration_sequence.pop
-    end
-
     def evicted(env_name)
       @evicted_envs << env_name
     end
   end
-
 end
 end

data/spec/unit/face/config_spec.rb

@@ -138,7 +138,7 @@ trace = true
       Puppet[:log_level] = 'info'
       allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
       expect {
-        subject.set('foo', 'bar')
+        subject.set('certname', 'bar')
       }.to output("\e[1;33mResolving settings from section 'main' in environment 'production'\e[0m\n").to_stderr
     end
 
@@ -146,19 +146,19 @@ trace = true
       Puppet[:log_level] = 'info'
       allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
       expect {
-        subject.set('foo', 'bar', {:section => "baz"})
+        subject.set('certname', 'bar', {:section => "baz"})
       }.to output("\e[1;33mResolving settings from section 'baz' in environment 'production'\e[0m\n").to_stderr
     end
 
     it "writes to the correct puppet config file" do
       expect(Puppet::FileSystem).to receive(:open).with(path, anything, anything)
-      subject.set('foo', 'bar')
+      subject.set('certname', 'bar')
     end
 
     it "creates a config file if one does not exist" do
       allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
       expect(Puppet::FileSystem).to receive(:touch).with(path)
-      subject.set('foo', 'bar')
+      subject.set('certname', 'bar')
     end
 
     it "sets the supplied config/value in the default section (main)" do
@@ -167,8 +167,8 @@ trace = true
       manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
       allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
 
-      expect(manipulator).to receive(:set).with("main", "foo", "bar")
-      subject.set('foo', 'bar')
+      expect(manipulator).to receive(:set).with("main", "certname", "bar")
+      subject.set('certname', 'bar')
     end
 
     it "sets the value in the supplied section" do
@@ -177,8 +177,8 @@ trace = true
       manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
       allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
 
-      expect(manipulator).to receive(:set).with("baz", "foo", "bar")
-      subject.set('foo', 'bar', {:section => "baz"})
+      expect(manipulator).to receive(:set).with("baz", "certname", "bar")
+      subject.set('certname', 'bar', {:section => "baz"})
     end
 
     it "does not duplicate an existing default section when a section is not specified" do
@@ -190,15 +190,48 @@ trace = true
       myfile = StringIO.new(contents)
       allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myfile)
 
-      subject.set('foo', 'bar')
+      subject.set('certname', 'bar')
 
-      expect(myfile.string).to match(/foo = bar/)
+      expect(myfile.string).to match(/certname = bar/)
       expect(myfile.string).not_to match(/main.*main/)
     end
 
     it "opens the file with UTF-8 encoding" do
       expect(Puppet::FileSystem).to receive(:open).with(path, nil, 'r+:UTF-8')
-      subject.set('foo', 'bar')
+      subject.set('certname', 'bar')
+    end
+
+    it "sets settings into the [server] section when setting [master] section settings" do
+      initial_contents = <<~CONFIG
+        [master]
+        node_terminus = none
+        reports = log
+      CONFIG
+
+      myinitialfile = StringIO.new(initial_contents)
+      allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myinitialfile)
+
+      expect {
+        subject.set('node_terminus', 'exec', {:section => 'master'})
+      }.to output("Deleted setting from 'master': 'node_terminus = none', and adding it to 'server' section\n").to_stdout
+
+      expect(myinitialfile.string).to match(<<~CONFIG)
+        [master]
+        reports = log
+        [server]
+        node_terminus = exec
+      CONFIG
+    end
+
+    it "setting [master] section settings, sets settings into [server] section instead" do
+      myinitialfile = StringIO.new("")
+      allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myinitialfile)
+      subject.set('node_terminus', 'exec', {:section => 'master'})
+
+      expect(myinitialfile.string).to match(<<~CONFIG)
+        [server]
+        node_terminus = exec
+      CONFIG
     end
   end
 
@@ -234,7 +267,9 @@ trace = true
       allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
 
       expect(manipulator).to receive(:delete).with('main', 'setting').and_return('    setting=value')
-      expect { subject.delete('setting', {:section => 'main'}) }.to have_printed("Deleted setting from 'main': 'setting=value'")
+      expect {
+        subject.delete('setting', {:section => 'main'})
+      }.to output("Deleted setting from 'main': 'setting=value'\n").to_stdout
     end
 
     it 'prints a warning when a setting is not found to delete' do
@@ -247,6 +282,24 @@ trace = true
       expect(Puppet).to receive(:warning).with("No setting found in configuration file for section 'main' setting name 'setting'")
       subject.delete('setting', {:section => 'main'})
     end
+
+    ['master', 'server'].each do |section|
+      describe "when deleting from [#{section}] section" do
+        it "deletes section values from both [server] and [master] sections" do
+          allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
+          config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+          manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+          allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
+
+          expect(manipulator).to receive(:delete).with('master', 'setting').and_return('setting=value')
+          expect(manipulator).to receive(:delete).with('server', 'setting').and_return('setting=value')
+          expect {
+            subject.delete('setting', {:section => section})
+          }.to output(/Deleted setting from 'master': 'setting'\nDeleted setting from 'server': 'setting'\n/).to_stdout
+        end
+      end
+    end
+
   end
 
   shared_examples_for :config_printing_a_section do |section|

data/spec/unit/face/facts_spec.rb

@@ -71,4 +71,8 @@ CONF
                                log.message =~ /Uploading facts for '.*' to 'puppet\.server\.test'/}
     end
   end
+
+  describe "#show" do
+    it { is_expected.to be_action :show }
+  end
 end