puppet 6.14.0-x86-mingw32 → 6.19.0-x86-mingw32

data/spec/shared_contexts/types_setup.rb

@@ -187,6 +187,8 @@ shared_context 'types_setup' do
     result << Puppet::Pops::Types::PURIType
     result << Puppet::Pops::Types::PTupleType.new([tf.rich_data])
     result << Puppet::Pops::Types::PObjectType
+    result << Puppet::Pops::Types::PTypeType
+    result << Puppet::Pops::Types::PTypeSetType
     result
   end
   def rich_data_compatible_types

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/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/doc_spec.rb

@@ -234,8 +234,8 @@ describe Puppet::Application::Doc do
         end
       end
 
-      it "should operate in master run_mode" do
-        expect(@doc.class.run_mode.name).to eq(:master)
+      it "should operate in server run_mode" do
+        expect(@doc.class.run_mode.name).to eq(:server)
 
         @doc.setup_rdoc
       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,52 @@ require 'spec_helper'
 require 'puppet/application/facts'
 
 describe Puppet::Application::Facts do
+  let(:app) { Puppet::Application[:facts] }
+  let(:values) { {"filesystems" => "apfs,autofs,devfs", "macaddress" => "64:52:11:22:03:25"} }
+
   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
+        macaddress: "64:52:11:22:03:25"
+    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
+        macaddress: "64:52:11:22:03:25"
+    END
+
+    expect {
+      app.run
+    }.to exit_with(0)
+     .and output(expected).to_stdout
   end
 end

data/spec/unit/application/filebucket_spec.rb

@@ -114,12 +114,31 @@ describe Puppet::Application::Filebucket do
         @filebucket.setup
       end
 
-      it "should default to the first server_list entry if set" do
+      it "should default to the first good server_list entry if server_list is set" do
+        stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 200)
         Puppet[:server_list] = "foo,bar,baz"
         expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "foo"))
         @filebucket.setup
       end
 
+      it "should walk server_list until it finds a good entry" do
+        stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 502)
+        stub_request(:get, "https://bar:8140/status/v1/simple/master").to_return(status: 200)
+        Puppet[:server_list] = "foo,bar,baz"
+        expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "bar"))
+        @filebucket.setup
+      end
+
+      # FileBucket catches any exceptions raised, logs them, then just exits
+      it "raises an error if there are no functional servers in server_list" do
+        stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 404)
+        stub_request(:get, "https://bar:8140/status/v1/simple/master").to_return(status: 404)
+        Puppet[:server] = 'horacio'
+        Puppet[:server_list] = "foo,bar"
+
+        expect{@filebucket.setup}.to exit_with(1)
+      end
+
       it "should fall back to server if server_list is empty" do
         Puppet[:server_list] = ""
         expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "puppet"))
@@ -127,8 +146,9 @@ describe Puppet::Application::Filebucket do
       end
 
       it "should take both the server and port specified in server_list" do
+        stub_request(:get, "https://foo:632/status/v1/simple/master").to_return(status: 200)
         Puppet[:server_list] = "foo:632,bar:6215,baz:351"
-        expect(Puppet::FileBucket::Dipper).to receive(:new).with({ :Server => "foo", :Port => "632" })
+        expect(Puppet::FileBucket::Dipper).to receive(:new).with({ :Server => "foo", :Port => 632 })
         @filebucket.setup
       end
     end

data/spec/unit/application/man_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:man, :current] do
+  let(:pager) { '/path/to/our/pager' }
+
+  around do |example|
+    Puppet::Util.withenv('MANPAGER' => pager) do
+      example.run
+    end
+  end
+
+  it 'is deprecated' do
+    expect(subject).to be_deprecated
+  end
+
+  it 'has a man action' do
+    expect(subject).to be_action(:man)
+  end
+
+  it 'accepts a call with no arguments' do
+    expect { subject.man }.to output(/USAGE: puppet man <action>/).to_stdout
+  end
+
+  it 'raises an ArgumentError when given too many arguments' do
+    expect {
+      subject.man(:man, 'agent', 'extra')
+    }.to raise_error(ArgumentError)
+     .and output(/USAGE: puppet man <action>/).to_stdout
+  end
+
+  it "exits with 0 when generating man documentation for each available application" do
+    # turn off deprecation warning
+    Puppet[:disable_warnings] = ['deprecations']
+
+    allow(Puppet::Util).to receive(:which).with('ronn').and_return(nil)
+    allow(Puppet::Util).to receive(:which).with(pager).and_return(pager)
+
+    Puppet::Application.available_application_names.each do |name|
+      next if %w{man face_base indirection_base}.include? name
+
+      app = Puppet::Application[:man]
+      app.command_line.args << 'man' << name
+
+      expect {
+        allow(IO).to receive(:popen).with(pager, 'w:UTF-8').and_yield($stdout)
+        app.run
+      }.to exit_with(0)
+       .and output(/puppet-#{name}/m).to_stdout
+    end
+  end
+end

data/spec/unit/application/resource_spec.rb

@@ -51,7 +51,9 @@ describe Puppet::Application::Resource do
       # provider is a parameter that should always be available
       @resource_app.extra_params = [ :provider ]
 
-      expect { @resource_app.main }.to have_printed(/provider\s+=>/)
+      expect {
+        @resource_app.main
+      }.to output(/provider\s+=>/).to_stdout
     end
   end
 

data/spec/unit/application/ssl_spec.rb

@@ -38,7 +38,7 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
   def expects_command_to_pass(expected_output = nil)
     expect {
       ssl.run_command
-    }.to have_printed(expected_output)
+    }.to output(expected_output).to_stdout
   end
 
   def expects_command_to_fail(message)
@@ -46,7 +46,7 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       expect {
         ssl.run_command
       }.to raise_error(Puppet::Error, message)
-    }.to have_printed(/.*/) # ignore output
+    }.to output(/.*/).to_stdout
   end
 
   shared_examples_for 'an ssl action' do
@@ -266,6 +266,19 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       FileUtils.cp(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'encrypted-key.pem'), Puppet[:hostprivkey])
       FileUtils.cp(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'signed.pem'), Puppet[:hostcert])
 
+      # To verify the client cert we need the root and intermediate certs and crls.
+      # We don't need to do this with `ssl-client` cert above, because it is issued
+      # directly from the generated TestCa above.
+      File.open(Puppet[:localcacert], 'w') do |f|
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'ca.pem')))
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'intermediate.pem')))
+      end
+
+      File.open(Puppet[:hostcrl], 'w') do |f|
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'crl.pem')))
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'intermediate-crl.pem')))
+      end
+
       Puppet[:passfile] = file_containing('passfile', '74695716c8b6')
 
       expects_command_to_pass(%r{Verified client certificate 'CN=signed' fingerprint})