puppet 6.15.0-universal-darwin → 6.19.1-universal-darwin

data/spec/unit/confine_spec.rb

@@ -54,10 +54,11 @@ describe Puppet::Confine do
     end
 
     it "should log failing confines with the label and message" do
+      Puppet[:log_level] = 'debug'
       allow(@confine).to receive(:pass?).and_return(false)
       expect(@confine).to receive(:message).and_return("My message")
       expect(@confine).to receive(:label).and_return("Mylabel")
-      expect(Puppet).to receive(:debug).with("Mylabel: My message")
+      expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("Mylabel: My message") }
       @confine.valid?
     end
   end

data/spec/unit/context/trusted_information_spec.rb

@@ -41,8 +41,12 @@ describe Puppet::Context::TrustedInformation, :unless => RUBY_PLATFORM == 'java'
   }
 
   def allow_external_trusted_data(certname, data)
-    Puppet[:trusted_external_command] = '/usr/bin/generate_data.sh'
-    allow(Puppet::Util::Execution).to receive(:execute).with(['/usr/bin/generate_data.sh', certname], anything).and_return(JSON.dump(data))
+    command = 'generate_data.sh'
+    Puppet[:trusted_external_command] = command
+    # The expand_path bit is necessary b/c :trusted_external_command is a
+    # file_or_directory setting, and file_or_directory settings automatically
+    # expand the given path.
+    allow(Puppet::Util::Execution).to receive(:execute).with([File.expand_path(command), certname], anything).and_return(JSON.dump(data))
   end
 
   it "defaults external to an empty hash" do
@@ -90,6 +94,25 @@ describe Puppet::Context::TrustedInformation, :unless => RUBY_PLATFORM == 'java'
 
       expect(trusted.external).to eq(external_data)
     end
+
+    it 'does not run the trusted external command when creating a trusted context' do
+      Puppet[:trusted_external_command] = '/usr/bin/generate_data.sh'
+
+      expect(Puppet::Util::Execution).to receive(:execute).never
+      Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
+    end
+
+    it 'only runs the trusted external command the first time it is invoked' do
+      command = 'generate_data.sh'
+      Puppet[:trusted_external_command] = command
+
+      # See allow_external_trusted_data to understand why expand_path is necessary
+      expect(Puppet::Util::Execution).to receive(:execute).with([File.expand_path(command), 'cert name'], anything).and_return(JSON.dump(external_data)).once
+
+      trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
+      trusted.external
+      trusted.external
+    end
   end
 
   context "when local" do

data/spec/unit/daemon_spec.rb

@@ -32,13 +32,17 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
   let(:pidfile) { double("PidFile", :lock => true, :unlock => true, :file_path => 'fake.pid') }
   let(:scheduler) { RecordingScheduler.new }
 
-  let(:daemon) { Puppet::Daemon.new(pidfile, scheduler) }
+  let(:daemon) { Puppet::Daemon.new(agent, pidfile, scheduler) }
 
   before(:each) do
     allow(Signal).to receive(:trap)
     allow(daemon).to receive(:close_streams).and_return(nil)
   end
 
+  it "should fail when no agent is provided" do
+    expect { Puppet::Daemon.new(nil, pidfile, scheduler) }.to raise_error(Puppet::DevError)
+  end
+
   it "should reopen the Log logs when told to reopen logs" do
     expect(Puppet::Util::Log).to receive(:reopen)
     daemon.reopen_logs
@@ -72,65 +76,21 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
       allow(daemon).to receive(:set_signal_traps)
     end
 
-    it "should fail if it has neither agent nor server" do
-      expect { daemon.start }.to raise_error(Puppet::DevError)
-    end
-
     it "should create its pidfile" do
       expect(pidfile).to receive(:lock).and_return(true)
-
-      daemon.agent = agent
       daemon.start
     end
 
     it "should fail if it cannot lock" do
       expect(pidfile).to receive(:lock).and_return(false)
-      daemon.agent = agent
-
       expect { daemon.start }.to raise_error(RuntimeError, "Could not create PID file: #{pidfile.file_path}")
     end
 
-    it "should start its server if one is configured" do
-      daemon.server = server
-
-      expect(server).to receive(:start)
-
-      daemon.start
-    end
-
     it "disables the reparse of configs if the filetimeout is 0" do
       Puppet[:filetimeout] = 0
-      daemon.agent = agent
-
       daemon.start
-
       expect(scheduler.jobs[0]).not_to be_enabled
     end
-
-    it "disables the agent run when there is no agent" do
-      Puppet[:filetimeout] = 0
-      daemon.server = server
-
-      daemon.start
-
-      expect(scheduler.jobs[1]).not_to be_enabled
-    end
-
-    it "waits for the server to shutdown when there is one" do
-      daemon.server = server
-
-      expect(server).to receive(:wait_for_shutdown)
-
-      daemon.start
-    end
-
-    it "waits for the server to shutdown when there is one" do
-      daemon.server = server
-
-      expect(server).to receive(:wait_for_shutdown)
-
-      daemon.start
-    end
   end
 
   describe "when stopping" do
@@ -146,14 +106,6 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
       without_warnings { Puppet::Application = Puppet::Application.superclass }
     end
 
-    it "should stop its server if one is configured" do
-      expect(server).to receive(:stop)
-
-      daemon.server = server
-
-      expect { daemon.stop }.to exit_with 0
-    end
-
     it 'should request a stop from Puppet::Application' do
       expect(Puppet::Application).to receive(:stop!)
       expect { daemon.stop }.to exit_with 0
@@ -161,7 +113,6 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
 
     it "should remove its pidfile" do
       expect(pidfile).to receive(:unlock)
-
       expect { daemon.stop }.to exit_with 0
     end
 
@@ -188,8 +139,6 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
       expect(agent).to receive(:run).with({:splay => false}).and_raise(Puppet::LockError, 'Failed to aquire lock')
       expect(Puppet).to receive(:notice).with('Not triggering already-running agent')
 
-      daemon.agent = agent
-
       daemon.reload
     end
 
@@ -197,8 +146,6 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
       expect(agent).to receive(:run).with({:splay => false})
       expect(Puppet).not_to receive(:notice).with('Not triggering already-running agent')
 
-      daemon.agent = agent
-
       daemon.reload
     end
   end
@@ -220,15 +167,11 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
 
     it "should reexec itself if no agent is available" do
       expect(daemon).to receive(:reexec)
-
       daemon.restart
     end
 
     it "should reexec itself if the agent is not running" do
-      expect(agent).to receive(:running?).and_return(false)
-      daemon.agent = agent
       expect(daemon).to receive(:reexec)
-
       daemon.restart
     end
   end
@@ -247,14 +190,12 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
     it "should shut down without exiting" do
       daemon.argv = %w{foo}
       expect(daemon).to receive(:stop).with(:exit => false)
-
       daemon.reexec
     end
 
     it "should call 'exec' with the original executable and arguments" do
       daemon.argv = %w{foo}
       expect(daemon).to receive(:exec).with($0 + " foo")
-
       daemon.reexec
     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,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).
@@ -746,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|