puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/application/agent_spec.rb

@@ -1,8 +1,8 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/agent'
 require 'puppet/application/agent'
-require 'puppet/network/server'
 require 'puppet/daemon'
 
 describe Puppet::Application::Agent do
@@ -12,29 +12,28 @@ describe Puppet::Application::Agent do
     @puppetd = Puppet::Application[:agent]
 
     @daemon = Puppet::Daemon.new(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)
+    @daemon.stubs(:daemonize)
+    @daemon.stubs(:start)
+    @daemon.stubs(:stop)
+    Puppet::Daemon.stubs(:new).returns(@daemon)
     Puppet[:daemonize] = false
 
-    @agent = double('agent')
-    allow(Puppet::Agent).to receive(:new).and_return(@agent)
+    @agent = stub_everything 'agent'
+    Puppet::Agent.stubs(:new).returns(@agent)
 
     @puppetd.preinit
-    allow(Puppet::Util::Log).to receive(:newdestination)
+    Puppet::Util::Log.stubs(:newdestination)
 
-    @ssl_host = double('ssl host')
-    allow(@ssl_host).to receive(:wait_for_cert)
-    allow(Puppet::SSL::Host).to receive(:new).and_return(@ssl_host)
+    @ssl_host = stub_everything 'ssl host'
+    Puppet::SSL::Host.stubs(:new).returns(@ssl_host)
 
-    allow(Puppet::Node.indirection).to receive(:terminus_class=)
-    allow(Puppet::Node.indirection).to receive(:cache_class=)
-    allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
+    Puppet::Node.indirection.stubs(:terminus_class=)
+    Puppet::Node.indirection.stubs(:cache_class=)
+    Puppet::Node::Facts.indirection.stubs(:terminus_class=)
 
-    expect($stderr).not_to receive(:puts)
+    $stderr.expects(:puts).never
 
-    allow(Puppet.settings).to receive(:use)
+    Puppet.settings.stubs(:use)
   end
 
   it "should operate in agent run_mode" do
@@ -59,7 +58,7 @@ describe Puppet::Application::Agent do
 
   describe "in preinit" do
     it "should catch INT" do
-      expect(Signal).to receive(:trap).with(:INT)
+      Signal.expects(:trap).with { |arg,block| arg == :INT }
 
       @puppetd.preinit
     end
@@ -97,7 +96,7 @@ describe Puppet::Application::Agent do
 
   describe "when handling options" do
     before do
-      allow(@puppetd.command_line).to receive(:args).and_return([])
+      @puppetd.command_line.stubs(:args).returns([])
     end
 
     [:enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
@@ -127,39 +126,39 @@ describe Puppet::Application::Agent do
     end
 
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
-      allow(@agent).to receive(:run).and_return(2)
+      @agent.stubs(:run).returns(2)
       Puppet[:onetime] = true
 
-      expect(@ssl_host).to receive(:wait_for_cert).with(0)
+      @ssl_host.expects(:wait_for_cert).with(0)
 
       expect { execute_agent }.to exit_with 0
     end
 
     it "should use supplied waitforcert when --onetime is specified" do
-      allow(@agent).to receive(:run).and_return(2)
+      @agent.stubs(:run).returns(2)
       Puppet[:onetime] = true
       @puppetd.handle_waitforcert(60)
 
-      expect(@ssl_host).to receive(:wait_for_cert).with(60)
+      @ssl_host.expects(:wait_for_cert).with(60)
 
       expect { execute_agent }.to exit_with 0
     end
 
     it "should use a default value for waitforcert when --onetime and --waitforcert are not specified" do
-      expect(@ssl_host).to receive(:wait_for_cert).with(120)
+      @ssl_host.expects(:wait_for_cert).with(120)
 
       execute_agent
     end
 
     it "should use the waitforcert setting when checking for a signed certificate" do
       Puppet[:waitforcert] = 10
-      expect(@ssl_host).to receive(:wait_for_cert).with(10)
+      @ssl_host.expects(:wait_for_cert).with(10)
 
       execute_agent
     end
 
     it "should set the log destination with --logdest" do
-      expect(Puppet::Log).to receive(:newdestination).with("console")
+      Puppet::Log.expects(:newdestination).with("console")
 
       @puppetd.handle_logdest("console")
     end
@@ -171,9 +170,9 @@ describe Puppet::Application::Agent do
     end
 
     it "should parse the log destination from the command line" do
-      allow(@puppetd.command_line).to receive(:args).and_return(%w{--logdest /my/file})
+      @puppetd.command_line.stubs(:args).returns(%w{--logdest /my/file})
 
-      expect(Puppet::Util::Log).to receive(:newdestination).with("/my/file")
+      Puppet::Util::Log.expects(:newdestination).with("/my/file")
 
       @puppetd.parse_options
     end
@@ -187,25 +186,25 @@ describe Puppet::Application::Agent do
 
   describe "during setup" do
     before :each do
-      allow(Puppet).to receive(:info)
+      Puppet.stubs(:info)
       Puppet[:libdir] = "/dev/null/lib"
-      allow(Puppet::Transaction::Report.indirection).to receive(:terminus_class=)
-      allow(Puppet::Transaction::Report.indirection).to receive(:cache_class=)
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class=)
-      allow(Puppet::Resource::Catalog.indirection).to receive(:cache_class=)
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
-      allow(Puppet).to receive(:settraps)
+      Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
+      Puppet::Transaction::Report.indirection.stubs(:cache_class=)
+      Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
+      Puppet::Resource::Catalog.indirection.stubs(:cache_class=)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class=)
+      Puppet.stubs(:settraps)
     end
 
     it "should not run with extra arguments" do
-      allow(@puppetd.command_line).to receive(:args).and_return(%w{disable})
+      @puppetd.command_line.stubs(:args).returns(%w{disable})
       expect{@puppetd.setup}.to raise_error ArgumentError, /does not take parameters/
     end
 
     describe "with --test" do
       it "should call setup_test" do
         @puppetd.options[:test] = true
-        expect(@puppetd).to receive(:setup_test)
+        @puppetd.expects(:setup_test)
 
         @puppetd.setup
       end
@@ -228,13 +227,13 @@ describe Puppet::Application::Agent do
     end
 
     it "should call setup_logs" do
-      expect(@puppetd).to receive(:setup_logs)
+      @puppetd.expects(:setup_logs)
       @puppetd.setup
     end
 
     describe "when setting up logs" do
       before :each do
-        allow(Puppet::Util::Log).to receive(:newdestination)
+        Puppet::Util::Log.stubs(:newdestination)
       end
 
       it "should set log level to debug if --debug was passed" do
@@ -253,8 +252,8 @@ describe Puppet::Application::Agent do
         it "should set console as the log destination with level #{level}" do
           @puppetd.options[level] = true
 
-          allow(Puppet::Util::Log).to receive(:newdestination)
-          expect(Puppet::Util::Log).to receive(:newdestination).with(:console).exactly(:once)
+          Puppet::Util::Log.expects(:newdestination).at_least_once
+          Puppet::Util::Log.expects(:newdestination).with(:console).once
 
           @puppetd.setup_logs
         end
@@ -263,15 +262,16 @@ describe Puppet::Application::Agent do
       it "should set a default log destination if no --logdest" do
         @puppetd.options[:setdest] = false
 
-        expect(Puppet::Util::Log).to receive(:setup_default)
+        Puppet::Util::Log.expects(:setup_default)
 
         @puppetd.setup_logs
       end
+
     end
 
     it "should print puppet config if asked to in Puppet config" do
-      Puppet[:configprint] = "pluginsync"
-      expect(Puppet.settings).to receive(:print_configs).and_return(true)
+      Puppet[:configprint] = "plugindest"
+      Puppet.settings.expects(:print_configs).returns true
       expect { execute_agent }.to exit_with 0
     end
 
@@ -279,37 +279,32 @@ describe Puppet::Application::Agent do
       path = make_absolute('/my/path')
       Puppet[:modulepath] = path
       Puppet[:configprint] = "modulepath"
-      expect_any_instance_of(Puppet::Settings).to receive(:puts).with(path)
+      Puppet::Settings.any_instance.expects(:puts).with(path)
       expect { execute_agent }.to exit_with 0
     end
 
     it "should use :main, :puppetd, and :ssl" do
-      expect(Puppet.settings).to receive(:use).with(:main, :agent, :ssl)
-
-      @puppetd.setup
-    end
-
-    it "should install a remote ca location" do
-      expect(Puppet::SSL::Host).to receive(:ca_location=).with(:remote)
+      Puppet.settings.unstub(:use)
+      Puppet.settings.expects(:use).with(:main, :agent, :ssl)
 
       @puppetd.setup
     end
 
-    it "should install a none ca location in fingerprint mode" do
+    it "should setup an agent in fingerprint mode" do
       @puppetd.options[:fingerprint] = true
-      expect(Puppet::SSL::Host).to receive(:ca_location=).with(:none)
+      @puppetd.expects(:setup_agent).never
 
       @puppetd.setup
     end
 
     it "should tell the report handler to use REST" do
-      expect(Puppet::Transaction::Report.indirection).to receive(:terminus_class=).with(:rest)
+      Puppet::Transaction::Report.indirection.expects(:terminus_class=).with(:rest)
 
       @puppetd.setup
     end
 
     it "should tell the report handler to cache locally as yaml" do
-      expect(Puppet::Transaction::Report.indirection).to receive(:cache_class=).with(:yaml)
+      Puppet::Transaction::Report.indirection.expects(:cache_class=).with(:yaml)
 
       @puppetd.setup
     end
@@ -325,7 +320,7 @@ describe Puppet::Application::Agent do
     end
 
     it "has an application default :catalog_cache_terminus setting of 'json'" do
-      expect(Puppet::Resource::Catalog.indirection).to receive(:cache_class=).with(:json)
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:json)
 
       @puppetd.initialize_app_defaults
       @puppetd.setup
@@ -333,7 +328,7 @@ describe Puppet::Application::Agent do
 
     it "should tell the catalog cache class based on the :catalog_cache_terminus setting" do
       Puppet[:catalog_cache_terminus] = "yaml"
-      expect(Puppet::Resource::Catalog.indirection).to receive(:cache_class=).with(:yaml)
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:yaml)
 
       @puppetd.initialize_app_defaults
       @puppetd.setup
@@ -341,7 +336,8 @@ describe Puppet::Application::Agent do
 
     it "should not set catalog cache class if :catalog_cache_terminus is explicitly nil" do
       Puppet[:catalog_cache_terminus] = nil
-      expect(Puppet::Resource::Catalog.indirection).not_to receive(:cache_class=)
+      Puppet::Resource::Catalog.indirection.unstub(:cache_class=)
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).never
 
       @puppetd.initialize_app_defaults
       @puppetd.setup
@@ -353,7 +349,7 @@ describe Puppet::Application::Agent do
     end
 
     it "should create an agent" do
-      allow(Puppet::Agent).to receive(:new).with(Puppet::Configurer)
+      Puppet::Agent.stubs(:new).with(Puppet::Configurer)
 
       @puppetd.setup
     end
@@ -361,7 +357,7 @@ describe Puppet::Application::Agent do
     [:enable, :disable].each do |action|
       it "should delegate to enable_disable_client if we #{action} the agent" do
         @puppetd.options[action] = true
-        expect(@puppetd).to receive(:enable_disable_client).with(@agent)
+        @puppetd.expects(:enable_disable_client).with(@agent)
 
         @puppetd.setup
       end
@@ -371,7 +367,7 @@ describe Puppet::Application::Agent do
       [:enable, :disable].each do |action|
         it "should call client.#{action}" do
           @puppetd.options[action] = true
-          expect(@agent).to receive(action)
+          @agent.expects(action)
           expect { execute_agent }.to exit_with 0
         end
       end
@@ -379,7 +375,7 @@ describe Puppet::Application::Agent do
       it "should pass the disable message when disabling" do
         @puppetd.options[:disable] = true
         @puppetd.options[:disable_message] = "message"
-        expect(@agent).to receive(:disable).with("message")
+        @agent.expects(:disable).with("message")
 
         expect { execute_agent }.to exit_with 0
       end
@@ -387,7 +383,7 @@ describe Puppet::Application::Agent do
       it "should pass the default disable message when disabling without a message" do
         @puppetd.options[:disable] = true
         @puppetd.options[:disable_message] = nil
-        expect(@agent).to receive(:disable).with("reason not specified")
+        @agent.expects(:disable).with("reason not specified")
 
         expect { execute_agent }.to exit_with 0
       end
@@ -402,17 +398,18 @@ describe Puppet::Application::Agent do
     end
 
     it "should daemonize if needed" do
-      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
+      Puppet::Util::Platform.stubs(:windows?).returns false
       Puppet[:daemonize] = true
+      Signal.stubs(:trap)
 
-      expect(@daemon).to receive(:daemonize)
+      @daemon.expects(:daemonize)
 
       execute_agent
     end
 
     it "should wait for a certificate" do
       @puppetd.options[:waitforcert] = 123
-      expect(@ssl_host).to receive(:wait_for_cert).with(123)
+      @ssl_host.expects(:wait_for_cert).with(123)
 
       execute_agent
     end
@@ -422,12 +419,12 @@ describe Puppet::Application::Agent do
       @puppetd.options[:waitforcert] = 123
       @puppetd.options[:digest] = 'MD5'
 
-      certificate = double('certificate')
-      allow(certificate).to receive(:digest).with('MD5').and_return('ABCDE')
-      allow(@ssl_host).to receive(:certificate).and_return(certificate)
+      certificate = mock 'certificate'
+      certificate.stubs(:digest).with('MD5').returns('ABCDE')
+      @ssl_host.stubs(:certificate).returns(certificate)
 
-      expect(@ssl_host).not_to receive(:wait_for_cert)
-      expect(@puppetd).to receive(:puts).with('ABCDE')
+      @ssl_host.expects(:wait_for_cert).never
+      @puppetd.expects(:puts).with('ABCDE')
 
       execute_agent
     end
@@ -438,35 +435,36 @@ describe Puppet::Application::Agent do
       end
 
       it "should not setup as an agent" do
-        expect(@puppetd).not_to receive(:setup_agent)
+        @puppetd.expects(:setup_agent).never
         @puppetd.setup
       end
 
       it "should not create an agent" do
-        expect(Puppet::Agent).not_to receive(:new).with(Puppet::Configurer)
+        Puppet::Agent.stubs(:new).with(Puppet::Configurer).never
         @puppetd.setup
       end
 
       it "should not daemonize" do
-        expect(@daemon).not_to receive(:daemonize)
+        @daemon.expects(:daemonize).never
         @puppetd.setup
       end
     end
 
     describe "when configuring agent for catalog run" do
       it "should set should_fork as true when running normally" do
-        expect(Puppet::Agent).to receive(:new).with(anything, true)
+        Puppet::Agent.expects(:new).with(anything, true)
         @puppetd.setup
       end
 
       it "should not set should_fork as false for --onetime" do
         Puppet[:onetime] = true
-        expect(Puppet::Agent).to receive(:new).with(anything, false)
+        Puppet::Agent.expects(:new).with(anything, false)
         @puppetd.setup
       end
     end
   end
 
+
   describe "when running" do
     before :each do
       @puppetd.options[:fingerprint] = false
@@ -475,7 +473,7 @@ describe Puppet::Application::Agent do
     it "should dispatch to fingerprint if --fingerprint is used" do
       @puppetd.options[:fingerprint] = true
 
-      allow(@puppetd).to receive(:fingerprint)
+      @puppetd.stubs(:fingerprint)
 
       execute_agent
     end
@@ -483,7 +481,7 @@ describe Puppet::Application::Agent do
     it "should dispatch to onetime if --onetime is used" do
       @puppetd.options[:onetime] = true
 
-      allow(@puppetd).to receive(:onetime)
+      @puppetd.stubs(:onetime)
 
       execute_agent
     end
@@ -491,40 +489,41 @@ describe Puppet::Application::Agent do
     it "should dispatch to main if --onetime and --fingerprint are not used" do
       @puppetd.options[:onetime] = false
 
-      allow(@puppetd).to receive(:main)
+      @puppetd.stubs(:main)
 
       execute_agent
     end
 
     describe "with --onetime" do
+
       before :each do
-        allow(@agent).to receive(:run).and_return(:report)
+        @agent.stubs(:run).returns(:report)
         Puppet[:onetime] = true
         @puppetd.options[:client] = :client
         @puppetd.options[:detailed_exitcodes] = false
       end
 
       it "should setup traps" do
-        expect(@daemon).to receive(:set_signal_traps)
+        @daemon.expects(:set_signal_traps)
 
         expect { execute_agent }.to exit_with 0
       end
 
       it "should let the agent run" do
-        expect(@agent).to receive(:run).and_return(:report)
+        @agent.expects(:run).returns(:report)
 
         expect { execute_agent }.to exit_with 0
       end
 
       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)
+        @agent.expects(:run).with(:job_id => 'special id').returns(:report)
 
         expect { execute_agent }.to exit_with 0
       end
 
       it "should stop the daemon" do
-        expect(@daemon).to receive(:stop).with(:exit => false)
+        @daemon.expects(:stop).with(:exit => false)
 
         expect { execute_agent }.to exit_with 0
       end
@@ -536,14 +535,14 @@ describe Puppet::Application::Agent do
 
         it "should exit with agent computed exit status" do
           Puppet[:noop] = false
-          allow(@agent).to receive(:run).and_return(666)
+          @agent.stubs(:run).returns(666)
 
           expect { execute_agent }.to exit_with 666
         end
 
         it "should exit with the agent's exit status, even if --noop is set." do
           Puppet[:noop] = true
-          allow(@agent).to receive(:run).and_return(666)
+          @agent.stubs(:run).returns(666)
 
           expect { execute_agent }.to exit_with 666
         end
@@ -552,26 +551,26 @@ describe Puppet::Application::Agent do
 
     describe "with --fingerprint" do
       before :each do
-        @cert = double('cert')
+        @cert = mock 'cert'
         @puppetd.options[:fingerprint] = true
         @puppetd.options[:digest] = :MD5
       end
 
       it "should fingerprint the certificate if it exists" do
-        allow(@ssl_host).to receive(:certificate).and_return(@cert)
-        allow(@cert).to receive(:digest).with('MD5').and_return("fingerprint")
+        @ssl_host.stubs(:certificate).returns(@cert)
+        @cert.stubs(:digest).with('MD5').returns "fingerprint"
 
-        expect(@puppetd).to receive(:puts).with("fingerprint")
+        @puppetd.expects(:puts).with "fingerprint"
 
         @puppetd.fingerprint
       end
 
       it "should fingerprint the certificate request if no certificate have been signed" do
-        allow(@ssl_host).to receive(:certificate).and_return(nil)
-        allow(@ssl_host).to receive(:certificate_request).and_return(@cert)
-        allow(@cert).to receive(:digest).with('MD5').and_return("fingerprint")
+        @ssl_host.stubs(:certificate).returns(nil)
+        @ssl_host.stubs(:certificate_request).returns(@cert)
+        @cert.stubs(:digest).with('MD5').returns "fingerprint"
 
-        expect(@puppetd).to receive(:puts).with("fingerprint")
+        @puppetd.expects(:puts).with "fingerprint"
 
         @puppetd.fingerprint
       end
@@ -579,35 +578,17 @@ describe Puppet::Application::Agent do
 
     describe "without --onetime and --fingerprint" do
       before :each do
-        allow(Puppet).to receive(:notice)
+        Puppet.stubs(:notice)
       end
 
       it "should start our daemon" do
-        expect(@daemon).to receive(:start)
+        @daemon.expects(:start)
 
         execute_agent
       end
     end
   end
 
-  describe "when starting in daemon mode on non-windows", :unless => Puppet.features.microsoft_windows? do
-    before :each do
-      allow(Puppet).to receive(:notice)
-      Puppet[:daemonize] = true
-    end
-
-    it "should not print config in default mode" do
-      execute_agent
-      expect(@logs).to be_empty
-    end
-
-    it "should print config in debug mode" do
-      @puppetd.options[:debug] = true
-      execute_agent
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: /agent_catalog_run_lockfile=/))
-    end
-  end
-
   def execute_agent
     @puppetd.setup
     @puppetd.run_command