puppet 6.14.0-x64-mingw32 → 6.19.0-x64-mingw32

data/spec/unit/defaults_spec.rb

@@ -188,8 +188,31 @@ describe "Defaults" do
     end
 
     it "raises an exception if facter-ng could not be loaded" do
-      allow(Puppet).to receive(:require).with('facter-ng').and_return(false)
+      allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_raise(LoadError)
+
       expect{ Puppet.settings[:facterng] = true }.to raise_exception ArgumentError, 'facter-ng could not be loaded'
     end
+
+    context 'set logger' do
+      before do
+        @original_facter = Object.const_get(:Facter)
+
+        Object.send(:remove_const, :Facter)
+        Object.const_set(:Facter, Module.new)
+
+        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
+
+      after do
+        Object.const_set(:Facter, @original_facter)
+      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
+    end
   end
 end

data/spec/unit/environments_spec.rb

@@ -35,6 +35,7 @@ describe Puppet::Environments do
         FS::MemoryFile.a_directory("modules"),
         FS::MemoryFile.a_directory("manifests"),
       ]),
+      FS::MemoryFile.a_missing_file("missing")
     ])
   end
 
@@ -90,6 +91,13 @@ describe Puppet::Environments do
       end
     end
 
+    it "proceeds with non-existant env dir" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.last) do |loader|
+        expect(loader.list).to eq([])
+      end
+    end
+
     it "gets a particular environment" do
       loader_from(:filesystem => [directory_tree],
                   :directory => directory_tree.children.first) do |loader|
@@ -428,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
 
@@ -637,6 +626,102 @@ 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
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        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
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        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
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        # 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).
@@ -738,31 +823,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

@@ -200,6 +200,44 @@ trace = true
       expect(Puppet::FileSystem).to receive(:open).with(path, nil, 'r+:UTF-8')
       subject.set('foo', 'bar')
     end
+
+    it "sets settings into the [server] section when setting [master] section settings" do
+      initial_contents = <<-CONFIG
+[master]
+setting = old_setting_value
+untouched_setting = value
+      CONFIG
+
+      myinitialfile = StringIO.new(initial_contents)
+      allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myinitialfile)
+
+      expect {
+        subject.set('setting', 'new_setting_value', {:section => 'master'})
+      }.to output("Deleted setting from 'master': 'setting = old_setting_value', and adding it to 'server' section\n").to_stdout
+      modified_content = <<-CONFIG
+[master]
+untouched_setting = value
+[server]
+setting = new_setting_value
+      CONFIG
+
+      mymodifiedfile = StringIO.new(modified_content)
+      expect(myinitialfile.string).to match(mymodifiedfile.string)
+    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('setting_name', 'value', {:section => 'master'})
+
+      expected_content = <<-CONFIG
+[server]
+setting_name = value
+      CONFIG
+
+      myexpectedfile = StringIO.new(expected_content)
+      expect(myinitialfile.string).to match(myexpectedfile.string)
+    end
   end
 
   context 'when the puppet.conf file does not exist' do
@@ -234,7 +272,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 +287,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/module/search_spec.rb

@@ -211,4 +211,21 @@ describe "puppet module search" do
       end
     end
   end
+
+  it "should include a deprecation warning" do
+    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=puppetlabs-apache").to_return(status: 200, body: [answers: [], result: :success])
+
+    subject.search("puppetlabs-apache")
+
+    expect(@logs).to include(an_object_having_attributes(level: :warning, message: /This action has been deprecated. Please use the Puppet Forge to search for modules./))
+  end
+
+  it "omits the warning when deprecations are disabled" do
+    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=puppetlabs-apache").to_return(status: 200, body: [answers: [], result: :success])
+
+    Puppet[:disable_warnings] = 'deprecations'
+    subject.search("puppetlabs-apache")
+
+    expect(@logs).not_to include(an_object_having_attributes(level: :warning))
+  end
 end

data/spec/unit/face/node_spec.rb

@@ -74,9 +74,9 @@ describe Puppet::Face[:node, '0.0.1'] do
           subject.clean('hostname')
         end
 
-        it "should run in master mode" do
+        it "should run in server mode" do
           subject.clean('hostname')
-          expect(Puppet.run_mode).to be_master
+          expect(Puppet.run_mode).to be_server
         end
 
         it "should set node cache as yaml" do

data/spec/unit/file_serving/http_metadata_spec.rb

@@ -30,11 +30,6 @@ describe Puppet::FileServing::HttpMetadata do
     end
 
     context "with no Last-Modified or Content-MD5 header from the server" do
-      before do
-        allow(http_response).to receive(:[]).with('last-modified').and_return(nil)
-        allow(http_response).to receive(:[]).with('content-md5').and_return(nil)
-      end
-
       it "should use :mtime as the checksum type, based on current time" do
         # Stringifying Time.now does some rounding; do so here so we don't end up with a time
         # that's greater than the stringified version returned by collect.
@@ -51,13 +46,9 @@ describe Puppet::FileServing::HttpMetadata do
     context "with a Last-Modified header from the server" do
       let(:time) { Time.now.utc }
 
-      before do
-        allow(http_response).to receive(:[]).with('content-md5').and_return(nil)
-      end
-
       it "should use :mtime as the checksum type, based on Last-Modified" do
         # HTTP uses "GMT" not "UTC"
-        allow(http_response).to receive(:[]).with('last-modified').and_return(time.strftime("%a, %d %b %Y %T GMT"))
+        http_response.add_field('last-modified', time.strftime("%a, %d %b %Y %T GMT"))
         metadata = described_class.new(http_response)
         metadata.collect
         expect( metadata.checksum_type ).to eq :mtime
@@ -70,16 +61,48 @@ describe Puppet::FileServing::HttpMetadata do
       let(:base64) { Digest::MD5.new.base64digest input }
       let(:hex) { Digest::MD5.new.hexdigest input }
 
-      before do
-        allow(http_response).to receive(:[]).with('last-modified').and_return(nil)
-        allow(http_response).to receive(:[]).with('content-md5').and_return(base64)
+      it "should use the md5 checksum" do
+        http_response.add_field('content-md5', base64)
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :md5
+        expect( metadata.checksum ).to eq "{md5}#{hex}"
       end
+    end
+
+    context "with X-Checksum-Md5" do
+      let(:md5) { "c58989e9740a748de4f5054286faf99b" }
 
       it "should use the md5 checksum" do
+        http_response.add_field('X-Checksum-Md5', md5)
         metadata = described_class.new(http_response)
         metadata.collect
         expect( metadata.checksum_type ).to eq :md5
-        expect( metadata.checksum ).to eq "{md5}#{hex}"
+        expect( metadata.checksum ).to eq "{md5}#{md5}"
+      end
+    end
+
+    context "with X-Checksum-Sha1" do
+      let(:sha1) { "01e4d15746f4274b84d740a93e04b9fd2882e3ea" }
+
+      it "should use the SHA1 checksum" do
+        http_response.add_field('X-Checksum-Sha1', sha1)
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :sha1
+        expect( metadata.checksum ).to eq "{sha1}#{sha1}"
+      end
+    end
+
+    context "with X-Checksum-Sha256" do
+      let(:sha256) { "a3eda98259c30e1e75039c2123670c18105e1c46efb672e42ca0e4cbe77b002a" }
+
+      it "should use the SHA256 checksum" do
+        http_response.add_field('X-Checksum-Sha256', sha256)
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :sha256
+        expect( metadata.checksum ).to eq "{sha256}#{sha256}"
       end
     end
   end

data/spec/unit/file_serving/mount/locales_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::Locales do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have locales and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have locales and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:locales?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the locale paths for each module that has locales" do

data/spec/unit/file_serving/mount/pluginfacts_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::PluginFacts do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have plugins and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:pluginfacts?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the plugin paths for each module that has plugins" do

data/spec/unit/file_serving/mount/plugins_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::Plugins do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have plugins and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:plugins?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the plugin paths for each module that has plugins" do