puppet 6.14.0-universal-darwin → 6.19.0-universal-darwin

data/spec/unit/application_spec.rb

@@ -118,6 +118,11 @@ describe Puppet::Application do
       @appclass.run_mode :agent
       expect(@appclass.run_mode.name).to eq(:agent)
     end
+
+    it "considers :server to be master" do
+      @appclass.run_mode :server
+      expect(@appclass.run_mode).to be_master
+    end
   end
 
   describe ".environment_mode" do
@@ -147,7 +152,7 @@ describe Puppet::Application do
   describe "when dealing with run_mode" do
 
     class TestApp < Puppet::Application
-      run_mode :master
+      run_mode :server
       def run_command
         # no-op
       end
@@ -159,16 +164,16 @@ describe Puppet::Application do
       app = TestApp.new
       app.initialize_app_defaults
 
-      expect(Puppet.run_mode).to be_master
+      expect(Puppet.run_mode).to be_server
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #run" do
       app = TestApp.new
       app.run
 
-      expect(app.class.run_mode.name).to eq(:master)
+      expect(app.class.run_mode.name).to eq(:server)
 
-      expect(Puppet.run_mode).to be_master
+      expect(Puppet.run_mode).to be_server
     end
   end
 

data/spec/unit/configurer/downloader_spec.rb

@@ -228,5 +228,15 @@ describe Puppet::Configurer::Downloader do
 
       expect { @dler.evaluate }.not_to raise_error
     end
+
+    it "raises an exception if catalog application fails" do
+      Puppet[:ignore_plugin_errors] = false
+
+      expect(@dler.file).to receive(:retrieve).and_raise(Puppet::Error, "testing")
+
+      expect {
+        @dler.evaluate
+      }.to raise_error(Puppet::Error, /testing/)
+    end
   end
 end

data/spec/unit/configurer/fact_handler_spec.rb

@@ -104,7 +104,7 @@ describe Puppet::Configurer::FactHandler do
           expect(text).to include(test_fact[:encoded])
 
           # this is not sufficient to test whether these values are sent via HTTP GET or HTTP POST in actual catalog request
-          expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+          expect(JSON.parse(Puppet::Util.uri_unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
         end
       end
     end
@@ -129,7 +129,7 @@ describe Puppet::Configurer::FactHandler do
           expect(to_upload).to eq({:facts_format => 'application/json', :facts => text})
           expect(text).to include(test_fact[:encoded])
 
-          expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+          expect(JSON.parse(Puppet::Util.uri_unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
         end
       end
     end
@@ -138,9 +138,9 @@ describe Puppet::Configurer::FactHandler do
       facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
       Puppet::Node::Facts.indirection.save(facts)
 
-      # prefer URI.unescape but validate CGI also works
+      # prefer Puppet::Util.uri_unescape but validate CGI also works
       encoded_facts = facthandler.facts_for_uploading[:facts]
-      expect(URI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
+      expect(Puppet::Util.uri_unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
       expect(CGI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
     end
   end

data/spec/unit/configurer_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'puppet/configurer'
-require 'webmock/rspec'
 
 describe Puppet::Configurer do
   before do
@@ -85,6 +84,44 @@ describe Puppet::Configurer do
       expect(configurer.run).to eq(0)
     end
 
+    it "fails the run if pluginsync fails when usecacheonfailure is false" do
+      Puppet[:ignore_plugin_errors] = false
+
+      # --test implies these, set them so we don't fall back to a cached catalog
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = false
+
+      body = "{\"message\":\"Not Found: Could not find environment 'fasdfad'\",\"issue_kind\":\"RUNTIME_ERROR\"}"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+      stub_request(:get, %r{/puppet/v3/file_metadata/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+
+      configurer.run(pluginsync: true)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: %r{Failed to apply catalog: Failed to retrieve pluginfacts: Could not retrieve information from environment production source\(s\) puppet:///pluginfacts}))
+    end
+
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true" do
+      Puppet[:ignore_plugin_errors] = false
+
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = true
+
+      body = "{\"message\":\"Not Found: Could not find environment 'fasdfad'\",\"issue_kind\":\"RUNTIME_ERROR\"}"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+      stub_request(:get, %r{/puppet/v3/file_metadata/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+
+      expect(configurer.run(pluginsync: true, :report => report)).to eq(0)
+      expect(report.cached_catalog_status).to eq('on_failure')
+    end
+
     it "applies a cached catalog when it can't connect to the master" do
       error = Errno::ECONNREFUSED.new('Connection refused - connect(2)')
 
@@ -96,7 +133,8 @@ describe Puppet::Configurer do
     end
 
     it "should initialize a transaction report if one is not provided" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      # host and settings catalogs each create a report...
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report).twice
 
       configurer.run
     end
@@ -148,7 +186,7 @@ describe Puppet::Configurer do
       configurer = Puppet::Configurer.new("test_tuuid", "test_jid")
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      expect(Puppet::Transaction::Report).to receive(:new).with(anything, anything, 'test_tuuid', 'test_jid').and_return(report)
+      expect(Puppet::Transaction::Report).to receive(:new).with(anything, anything, 'test_tuuid', 'test_jid', anything).and_return(report)
       expect(configurer).to receive(:send_report).with(report)
 
       configurer.run
@@ -192,22 +230,21 @@ describe Puppet::Configurer do
     end
 
     it "should remove the report as a log destination when the run is finished" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
-      configurer.run
+      configurer.run(report: report)
 
       expect(Puppet::Util::Log.destinations).not_to include(report)
     end
 
-    it "should return the report exit_status as the result of the run" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-      expect(report).to receive(:exit_status).and_return(1234)
+    it "should return an exit status of 2 due to the notify resource 'changing'" do
+      cat = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+      cat.add_resource(Puppet::Type.type(:notify).new(:name => 'something changed'))
 
-      expect(configurer.run).to eq(1234)
+      expect(configurer.run(catalog: cat, report: report)).to eq(2)
     end
 
     it "should return nil if catalog application fails" do
-      expect_any_instance_of(Puppet::Resource::Catalog).to receive(:apply).and_raise(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+      expect(catalog).to receive(:apply).and_raise(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+
       expect(configurer.run(catalog: catalog, report: report)).to be_nil
     end
 
@@ -222,34 +259,28 @@ describe Puppet::Configurer do
     end
 
     it "should include the pre-run command failure in the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
       expect(report.logs.find { |x| x.message =~ /Could not run command from prerun_command/ }).to be
     end
 
     it "should send the transaction report even if the post-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
       expect(configurer).to receive(:send_report).with(report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should include the post-run command failure in the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect(report).to receive(:<<) { |log, _| expect(log.message).to match(/Could not run command from postrun_command/) }.at_least(:once)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should execute post-run command even if the pre-run command fails" do
@@ -262,34 +293,28 @@ describe Puppet::Configurer do
     end
 
     it "should finalize the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       expect(report).to receive(:finalize_report)
-      configurer.run
+      configurer.run(report: report)
     end
 
     it "should not apply the catalog if the pre-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect_any_instance_of(Puppet::Resource::Catalog).not_to receive(:apply)
       expect(configurer).to receive(:send_report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should apply the catalog, send the report, and return nil if the post-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect_any_instance_of(Puppet::Resource::Catalog).to receive(:apply)
       expect(configurer).to receive(:send_report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it 'includes total time metrics in the report after successfully applying the catalog' do
@@ -546,6 +571,15 @@ describe Puppet::Configurer do
     end
   end
 
+  def expects_pluginsync
+    metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":420,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
+    stub_request(:get, %r{/puppet/v3/file_metadatas/(plugins|locales)}).to_return(status: 200, body: metadata, headers: {'Content-Type' => 'application/json'})
+
+    # response retains owner/group/mode due to source_permissions => use
+    facts_metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":500,\"group\":500,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
+    stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(status: 200, body: facts_metadata, headers: {'Content-Type' => 'application/json'})
+  end
+
   def expects_new_catalog_only(catalog)
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
     expect(Puppet::Resource::Catalog.indirection).not_to receive(:find).with(anything, hash_including(ignore_terminus: true))
@@ -562,6 +596,7 @@ describe Puppet::Configurer do
   end
 
   def expects_fallback_to_new_catalog(catalog)
+    expects_pluginsync
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(nil)
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
   end
@@ -598,7 +633,6 @@ describe Puppet::Configurer do
       it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
         expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_fallback_to_new_catalog(catalog)
-        expect(configurer).to receive(:download_plugins)
 
         configurer.run
       end
@@ -636,6 +670,7 @@ describe Puppet::Configurer do
       it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
         expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_neither_new_or_cached_catalog
+        expects_pluginsync
 
         # after failing to use a cached catalog, we'll need to pluginsync before getting
         # a new catalog, which also fails.
@@ -656,8 +691,7 @@ describe Puppet::Configurer do
       end
 
       it "applies the catalog passed as options when the catalog cache terminus is not set" do
-        stub_request(:get, %r{/puppet/v3/file_metadatas?/plugins}).to_return(:status => 404)
-        stub_request(:get, %r{/puppet/v3/file_metadatas?/pluginfacts}).to_return(:status => 404)
+        expects_pluginsync
 
         catalog.add_resource(Puppet::Resource.new('notify', 'from apply'))
         configurer.run(catalog: catalog.to_ral)
@@ -1010,30 +1044,45 @@ describe Puppet::Configurer do
       options = {}
       configurer.run(options)
       expect(options[:report].master_used).to eq('myserver:123')
+      expect(options[:report].server_used).to eq('myserver:123')
     end
 
-    it "should report when a server is unavailable" do
+    it "should report when usecacheonfailure is false and server is unavailable" do
       Puppet.settings[:server_list] = ["myserver:123"]
+      Puppet[:usecacheonfailure] = false
 
       stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: [500, "Internal Server Error"])
 
-      allow(Puppet).to receive(:debug)
-      expect(Puppet).to receive(:debug).with("Puppet server myserver:123 is unavailable: 500 Internal Server Error")
-
       expect {
         configurer.run
-      }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list:/)
+      }.to raise_error(Puppet::Error, /Could not select a functional puppet server from server_list:/)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: /Puppet server myserver:123 is unavailable: 500 Internal Server Error/))
     end
 
     it "should error when no servers in 'server_list' are reachable" do
       Puppet.settings[:server_list] = "myserver:123,someotherservername"
+      Puppet[:usecacheonfailure] = false
 
       stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: 400)
       stub_request(:get, 'https://someotherservername:8140/status/v1/simple/master').to_return(status: 400)
 
       expect{
         configurer.run
-      }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list: 'myserver:123,someotherservername'/)
+      }.to raise_error(Puppet::Error, /Could not select a functional puppet server from server_list: 'myserver:123,someotherservername'/)
+    end
+
+    it "should not error when usecacheonfailure is true and no servers in 'server_list' are reachable" do
+      Puppet.settings[:server_list] = "myserver:123,someotherservername"
+      Puppet[:usecacheonfailure] = true
+
+      stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: 400)
+      stub_request(:get, 'https://someotherservername:8140/status/v1/simple/master').to_return(status: 400)
+
+      options = {}
+
+      expect(configurer.run(options)).to eq(0)
+      expect(options[:report].server_used).to be_nil
     end
 
     it "should not make multiple node requests when the server is found" do

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