puppet 6.13.0-x64-mingw32 → 6.18.0-x64-mingw32

data/spec/unit/agent_spec.rb

@@ -179,37 +179,78 @@ describe Puppet::Agent do
       expect(@agent.run).to eq(:result)
     end
 
+    describe "and a puppet agent is already running" do
+      before(:each) do
+        allow_any_instance_of(Object).to receive(:sleep)
+        lockfile = double('lockfile')
+        expect(@agent).to receive(:lockfile).and_return(lockfile).at_least(:once)
+        # so the lock method raises Puppet::LockError
+        allow(lockfile).to receive(:lock).and_return(false)
+      end
+
+      it "should notify that a run is already in progres" do
+        client = AgentTestClient.new
+        expect(AgentTestClient).to receive(:new).and_return(client)
+        expect(Puppet).to receive(:notice).with(/Run of .* already in progress; skipping .* exists/)
+        @agent.run
+      end
+
+      it "should inform that a run is already in progres and try to run every X seconds if waitforlock is used" do
+        # so the locked file exists
+        allow(File).to receive(:file?).and_return(true)
+        # so we don't have to wait again for the run to exit (default maxwaitforcert is 60)
+        # first 0 is to get the time, second 0 is to inform user, then 1000 so the time expires
+        allow(Time).to receive(:now).and_return(0, 0, 1000)
+        allow(Puppet).to receive(:info)
+        client = AgentTestClient.new
+        expect(AgentTestClient).to receive(:new).and_return(client)
+
+        Puppet[:waitforlock] = 1
+        Puppet[:maxwaitforlock] = 2
+        expect(Puppet).to receive(:info).with(/Another puppet instance is already running; --waitforlock flag used, waiting for running instance to finish./)
+        expect(Puppet).to receive(:info).with(/Will try again in #{Puppet[:waitforlock]} seconds./)
+        @agent.run
+      end
+
+      it "should notify that the run is exiting if waitforlock is used and maxwaitforlock is exceeded" do
+        # so we don't have to wait again for the run to exit (default maxwaitforcert is 60)
+        # first 0 is to get the time, then 1000 so that the time expires
+        allow(Time).to receive(:now).and_return(0, 1000)
+        client = AgentTestClient.new
+        expect(AgentTestClient).to receive(:new).and_return(client)
+
+        Puppet[:waitforlock] = 1
+        expect(Puppet).to receive(:notice).with(/Exiting now because the maxwaitforlock timeout has been exceeded./)
+        @agent.run
+      end
+    end
+    
     describe "when should_fork is true", :if => Puppet.features.posix? && RUBY_PLATFORM != 'java' do
       before do
         @agent = Puppet::Agent.new(AgentTestClient, true)
 
         # So we don't actually try to hit the filesystem.
         allow(@agent).to receive(:lock).and_yield
-
-        allow(Kernel).to receive(:fork)
-        allow(Process).to receive(:waitpid2).and_return([123, double('process::status', :exitstatus => 0)])
-        allow(@agent).to receive(:exit)
       end
 
       it "should run the agent in a forked process" do
         client = AgentTestClient.new
         expect(AgentTestClient).to receive(:new).and_return(client)
 
-        expect(client).to receive(:run)
+        expect(client).to receive(:run).and_return(0)
 
         expect(Kernel).to receive(:fork).and_yield
-        @agent.run
+        expect { @agent.run }.to exit_with(0)
       end
 
       it "should exit child process if child exit" do
         client = AgentTestClient.new
         expect(AgentTestClient).to receive(:new).and_return(client)
 
-        expect(client).to receive(:run).and_raise(SystemExit)
+        expect(client).to receive(:run).and_raise(SystemExit.new(-1))
 
         expect(Kernel).to receive(:fork).and_yield
-        expect(@agent).to receive(:exit).with(-1)
-        @agent.run
+        expect { @agent.run }.to exit_with(-1)
       end
 
       it 'should exit with 1 if an exception is raised' do
@@ -219,31 +260,44 @@ describe Puppet::Agent do
         expect(client).to receive(:run).and_raise(StandardError)
 
         expect(Kernel).to receive(:fork).and_yield
-        expect(@agent).to receive(:exit).with(1)
-        @agent.run
+        expect { @agent.run }.to exit_with(1)
       end
 
-      it "should re-raise exit happening in the child" do
-        allow(Process).to receive(:waitpid2).and_return([123, double('process::status', :exitstatus => -1)])
-        expect { @agent.run }.to raise_error(SystemExit)
+      it 'should exit with 254 if NoMemoryError exception is raised' do
+        client = AgentTestClient.new
+        expect(AgentTestClient).to receive(:new).and_return(client)
+
+        expect(client).to receive(:run).and_raise(NoMemoryError)
+
+        expect(Kernel).to receive(:fork).and_yield
+        expect { @agent.run }.to exit_with(254)
       end
 
-      it "should re-raise NoMoreMemory happening in the child" do
-        allow(Process).to receive(:waitpid2).and_return([123, double('process::status', :exitstatus => -2)])
-        expect { @agent.run }.to raise_error(NoMemoryError)
+      it "should return the block exit code as the child exit code" do
+        expect(Kernel).to receive(:fork).and_yield
+        expect {
+          @agent.run_in_fork {
+            777
+          }
+        }.to exit_with(777)
       end
 
-      it "should return the child exit code" do
-        allow(Process).to receive(:waitpid2).and_return([123, double('process::status', :exitstatus => 777)])
-        expect(@agent.run).to eq(777)
+      it "should return `1` exit code if the block returns `nil`" do
+        expect(Kernel).to receive(:fork).and_yield
+        expect {
+          @agent.run_in_fork {
+            nil
+          }
+        }.to exit_with(1)
       end
 
-      it "should return the block exit code as the child exit code" do
+      it "should return `1` exit code if the block returns `false`" do
         expect(Kernel).to receive(:fork).and_yield
-        expect(@agent).to receive(:exit).with(777)
-        @agent.run_in_fork {
-          777
-        }
+        expect {
+          @agent.run_in_fork {
+            false
+          }
+        }.to exit_with(1)
       end
     end
 
@@ -283,7 +337,7 @@ describe Puppet::Agent do
         expect(client).not_to receive(:handling)
         expect(Puppet).to receive(:log_exception).with(be_an_instance_of(Puppet::Agent::RunTimeoutError), anything)
 
-        expect(@agent.run).to eq(1)
+        expect(@agent.run).to eq(nil)
       end
     end
   end

data/spec/unit/application/agent_spec.rb

@@ -12,16 +12,16 @@ describe Puppet::Application::Agent do
   before :each do
     @puppetd = Puppet::Application[:agent]
 
-    @daemon = Puppet::Daemon.new(nil)
+    @agent = double('agent')
+    allow(Puppet::Agent).to receive(:new).and_return(@agent)
+
+    @daemon = Puppet::Daemon.new(@agent, nil)
     allow(@daemon).to receive(:daemonize)
     allow(@daemon).to receive(:start)
     allow(@daemon).to receive(:stop)
     allow(Puppet::Daemon).to receive(:new).and_return(@daemon)
     Puppet[:daemonize] = false
 
-    @agent = double('agent')
-    allow(Puppet::Agent).to receive(:new).and_return(@agent)
-
     @puppetd.preinit
     allow(Puppet::Util::Log).to receive(:newdestination)
 
@@ -122,6 +122,10 @@ describe Puppet::Application::Agent do
       end
     end
 
+    it "should log the agent start time" do
+      expect(@puppetd.options[:start_time]).to be_a(Time)
+    end
+
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
       allow(@agent).to receive(:run).and_return(2)
       Puppet[:onetime] = true
@@ -505,7 +509,7 @@ describe Puppet::Application::Agent do
 
       it "should run the agent with the supplied job_id" do
         @puppetd.options[:job_id] = 'special id'
-        expect(@agent).to receive(:run).with(:job_id => 'special id').and_return(:report)
+        expect(@agent).to receive(:run).with(hash_including(:job_id => 'special id')).and_return(:report)
 
         expect { execute_agent }.to exit_with 0
       end
@@ -567,10 +571,9 @@ describe Puppet::Application::Agent do
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_request).and_return(nil)
 
         expect {
-          expect {
-            @puppetd.fingerprint
-          }.to exit_with(1)
-        }.to output(/Fingerprint asked but neither the certificate, nor the certificate request have been issued/).to_stderr
+          @puppetd.fingerprint
+        }.to exit_with(1)
+         .and output(/Fingerprint asked but neither the certificate, nor the certificate request have been issued/).to_stderr
       end
 
       it "should log an error if an exception occurs" do

data/spec/unit/application/describe_spec.rb

@@ -3,95 +3,133 @@ require 'spec_helper'
 require 'puppet/application/describe'
 
 describe Puppet::Application::Describe do
-  before :each do
-    @describe = Puppet::Application[:describe]
-  end
+  let(:describe) { Puppet::Application[:describe] }
+
+  it "lists all types" do
+    describe.command_line.args << '--list'
 
-  it "should declare a main command" do
-    expect(@describe).to respond_to(:main)
+    expect {
+      describe.run
+    }.to output(/These are the types known to puppet:/).to_stdout
   end
 
-  it "should declare a preinit block" do
-    expect(@describe).to respond_to(:preinit)
+  it "describes a single type" do
+    describe.command_line.args << 'exec'
+
+    expect {
+      describe.run
+    }.to output(/exec.*====.*Executes external commands/m).to_stdout
   end
 
-  [:providers,:list,:meta].each do |option|
-    it "should declare handle_#{option} method" do
-      expect(@describe).to respond_to("handle_#{option}".to_sym)
-    end
+  it "describes multiple types" do
+    describe.command_line.args.concat(['exec', 'file'])
 
-    it "should store argument value when calling handle_#{option}" do
-      expect(@describe.options).to receive(:[]=).with("#{option}".to_sym, 'arg')
-      @describe.send("handle_#{option}".to_sym, 'arg')
-    end
+    expect {
+      describe.run
+    }.to output(/Executes external commands.*Manages files, including their content, ownership, and permissions./m).to_stdout
   end
 
+  it "describes parameters for the type by default" do
+    describe.command_line.args << 'exec'
 
-  describe "in preinit" do
-    it "should set options[:parameters] to true" do
-      @describe.preinit
+    expect {
+      describe.run
+    }.to output(/Parameters\n----------/m).to_stdout
+  end
 
-      expect(@describe.options[:parameters]).to be_truthy
-    end
+  it "lists parameter names, but excludes description in short mode" do
+    describe.command_line.args.concat(['exec', '-s'])
+
+    expect {
+      describe.run
+    }.to output(/Parameters.*command, creates, cwd/m).to_stdout
   end
 
-  describe "when handling parameters" do
-    it "should set options[:parameters] to false" do
-      @describe.handle_short(nil)
+  it "outputs providers for the type" do
+    describe.command_line.args.concat(['exec', '--providers'])
 
-      expect(@describe.options[:parameters]).to be_falsey
-    end
+    expect {
+      describe.run
+    }.to output(/Providers.*#{Regexp.escape('**posix**')}.*#{Regexp.escape('**windows**')}/m).to_stdout
   end
 
-  describe "during setup" do
-    it "should collect arguments in options[:types]" do
-      allow(@describe.command_line).to receive(:args).and_return(['1','2'])
-      @describe.setup
+  it "lists metaparameters for a type" do
+    describe.command_line.args.concat(['exec', '--meta'])
 
-      expect(@describe.options[:types]).to eq(['1','2'])
-    end
+    expect {
+      describe.run
+    }.to output(/Meta Parameters.*#{Regexp.escape('**notify**')}/m).to_stdout
   end
 
-  describe "when running" do
+  it "outputs no documentation if the summary is missing" do
+    Puppet::Type.newtype(:describe_test) {}
+
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/#{Regexp.escape("describe_test   - .. no documentation ..")}/).to_stdout
+  end
 
-    before :each do
-      @typedoc = double('type_doc')
-      allow(TypeDoc).to receive(:new).and_return(@typedoc)
+  it "outputs the first short sentence ending in a dot" do
+    Puppet::Type.newtype(:describe_test) do
+      @doc = "ends in a dot."
     end
 
-    it "should call list_types if options list is set" do
-      @describe.options[:list] = true
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/#{Regexp.escape("describe_test   - ends in a dot\n")}/).to_stdout
+  end
 
-      expect(@typedoc).to receive(:list_types)
+  it "outputs the first short sentence missing a dot" do
+    Puppet::Type.newtype(:describe_test) do
+      @doc = "missing a dot"
+    end
 
-      @describe.run_command
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/describe_test   - missing a dot\n/).to_stdout
+  end
+
+  it "truncates long summaries ending in a dot" do
+    Puppet::Type.newtype(:describe_test) do
+      @doc = "This sentence is more than 45 characters and ends in a dot."
     end
 
-    it "should call format_type for each given types" do
-      @describe.options[:list] = false
-      @describe.options[:types] = ['type']
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/#{Regexp.escape("describe_test   - This sentence is more than 45 characters and  ...")}/).to_stdout
+  end
 
-      expect(@typedoc).to receive(:format_type).with('type', @describe.options)
-      @describe.run_command
+  it "truncates long summaries missing a dot" do
+    Puppet::Type.newtype(:describe_test) do
+      @doc = "This sentence is more than 45 characters and is missing a dot"
     end
+
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/#{Regexp.escape("describe_test   - This sentence is more than 45 characters and  ...")}/).to_stdout
   end
 
-  it "should format text with long non-space runs without garbling" do
-    @f = Formatter.new(76)
+  it "formats text with long non-space runs without garbling" do
+    f = Formatter.new(76)
 
-    @teststring = <<TESTSTRING
+    teststring = <<TESTSTRING
 . 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 nick@magpie.puppetlabs.lan
 **this part should not repeat!**
 TESTSTRING
 
-    @expected_result = <<EXPECTED
+    expected_result = <<EXPECTED
 .
 1234567890123456789012345678901234567890123456789012345678901234567890123456
 7890123456789012345678901234567890 nick@magpie.puppetlabs.lan
 **this part should not repeat!**
 EXPECTED
 
-    result = @f.wrap(@teststring, {:indent => 0, :scrub => true})
-    expect(result).to eql(@expected_result)
+    result = f.wrap(teststring, {:indent => 0, :scrub => true})
+    expect(result).to eql(expected_result)
   end
 end

data/spec/unit/application/device_spec.rb

@@ -459,7 +459,7 @@ describe Puppet::Application::Device do
           resource = Puppet::Type.type(:user).new(:name => "jim").to_resource
           allow(device.command_line).to receive(:args).and_return(['user', 'jim'])
           expect(Puppet::Resource.indirection).to receive(:find).with('user/jim').and_return(resource)
-          expect(device).to receive(:puts).with("user { 'jim':\n}")
+          expect(device).to receive(:puts).with("user { 'jim':\n  ensure => 'absent',\n}")
           expect { device.main }.to exit_with 0
         end
 
@@ -470,7 +470,7 @@ describe Puppet::Application::Device do
           allow(device.options).to receive(:[]).with(:to_yaml).and_return(true)
           allow(device.command_line).to receive(:args).and_return(['user'])
           expect(Puppet::Resource.indirection).to receive(:search).with('user/', {}).and_return(resources)
-          expect(device).to receive(:puts).with("---\nuser:\n  title: {}\n")
+          expect(device).to receive(:puts).with("---\nuser:\n  title:\n    ensure: absent\n")
           expect { device.main }.to exit_with 0
         end
       end

data/spec/unit/application/face_base_spec.rb

@@ -423,16 +423,18 @@ EOT
     it "should work if asked to render json" do
       allow(app.command_line).to receive(:args).and_return(%w{count_args a b c --render-as json})
       expect {
-        expect { app.run }.to exit_with(0)
-      }.to have_printed(/3/)
+        app.run
+      }.to exit_with(0)
+       .and output(/3/).to_stdout
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
       allow(app.command_line).to receive(:args).and_return(%w{with_s_rendering_hook --render-as s})
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
-        expect { app.run }.to exit_with(0)
-      }.to have_printed(/you invoked the 's' rendering hook/)
+        app.run
+      }.to exit_with(0)
+       .and output(/you invoked the 's' rendering hook/).to_stdout
     end
   end
 

data/spec/unit/application/facts_spec.rb

@@ -2,21 +2,50 @@ require 'spec_helper'
 require 'puppet/application/facts'
 
 describe Puppet::Application::Facts do
+  let(:app) { Puppet::Application[:facts] }
+  let(:values) { {"filesystems" => "apfs,autofs,devfs"} }
+
   before :each do
-    allow(subject.command_line).to receive(:subcommand_name).and_return('facts')
+    Puppet::Node::Facts.indirection.terminus_class = :memory
   end
 
-  it "should return facts if a key is given to find" do
-    Puppet::Node::Facts.indirection.reset_terminus_class
-    expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(Puppet::Node::Facts.new('whatever', {}))
-    allow(subject.command_line).to receive(:args).and_return(%w{find whatever --render-as yaml})
+  it "returns facts for a given node" do
+    facts = Puppet::Node::Facts.new('whatever', values)
+    Puppet::Node::Facts.indirection.save(facts)
+
+    app.command_line.args = %w{find whatever --render-as yaml}
+
+    # due to PUP-10105 we emit the class tag when we shouldn't
+    expected = Regexp.new(<<~END)
+      --- !ruby/object:Puppet::Node::Facts
+      name: whatever
+      values:
+        filesystems: apfs,autofs,devfs
+    END
 
     expect {
-      expect {
-        subject.run
-      }.to exit_with(0)
-    }.to have_printed(/object:Puppet::Node::Facts/)
+      app.run
+    }.to exit_with(0)
+     .and output(expected).to_stdout
+  end
 
-    expect(@logs).to be_empty
+  it "returns facts for the current node when the name is omitted" do
+    facts = Puppet::Node::Facts.new(Puppet[:certname], values)
+    Puppet::Node::Facts.indirection.save(facts)
+
+    app.command_line.args = %w{find --render-as yaml}
+
+    # due to PUP-10105 we emit the class tag when we shouldn't
+    expected = Regexp.new(<<~END)
+      --- !ruby/object:Puppet::Node::Facts
+      name: #{Puppet[:certname]}
+      values:
+        filesystems: apfs,autofs,devfs
+    END
+
+    expect {
+      app.run
+    }.to exit_with(0)
+     .and output(expected).to_stdout
   end
 end