puppet 6.29.0-universal-darwin → 7.0.0-universal-darwin

data/spec/spec_helper.rb

@@ -68,14 +68,26 @@ VCR.turn_off!
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 
-  exclude_filters = {}
+  # Examples or groups can selectively tag themselves as broken.
+  # For example;
+  #
+  # rbv = "#{RUBY_VERSION}-p#{RbConfig::CONFIG['PATCHLEVEL']}"
+  # describe "mostly working", :broken => false unless rbv == "1.9.3-p327" do
+  #  it "parses a valid IP" do
+  #    IPAddr.new("::2:3:4:5:6:7:8")
+  #  end
+  # end
+  exclude_filters = {:broken => true}
   exclude_filters[:benchmark] = true unless ENV['BENCHMARK']
   config.filter_run_excluding exclude_filters
 
   config.filter_run_when_matching :focus
 
   config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
+    # We really should have this on, but it breaks a _lot_ of tests. We'll
+    # need to go through and fix those tests first before it can be enabled
+    # for real.
+    mocks.verify_partial_doubles = false
   end
 
   tmpdir = Puppet::FileSystem.expand_path(Dir.mktmpdir("rspecrun"))
@@ -136,6 +148,7 @@ RSpec.configure do |config|
 
     base = PuppetSpec::Files.tmpdir('tmp_settings')
     Puppet[:vardir] = File.join(base, 'var')
+    Puppet[:publicdir] = File.join(base, 'public')
     Puppet[:confdir] = File.join(base, 'etc')
     Puppet[:codedir] = File.join(base, 'code')
     Puppet[:logdir] = "$vardir/log"
@@ -143,6 +156,7 @@ RSpec.configure do |config|
     Puppet[:hiera_config] = File.join(base, 'hiera')
 
     FileUtils.mkdir_p Puppet[:statedir]
+    FileUtils.mkdir_p Puppet[:publicdir]
 
     Puppet::Test::TestHelper.before_each_test()
   end
@@ -151,20 +165,10 @@ RSpec.configure do |config|
   PUPPET_FACTER_2_GCE_URL = %r{^http://metadata/computeMetadata/v1(beta1)?}.freeze
   PUPPET_FACTER_3_GCE_URL = "http://metadata.google.internal/computeMetadata/v1/?recursive=true&alt=json".freeze
 
-  # Facter azure metadata endpoint
-  PUPPET_FACTER_AZ_URL = "http://169.254.169.254/metadata/instance?api-version=2020-09-01"
-
-  # Facter EC2 endpoint
-  PUPPET_FACTER_EC2_METADATA_URL = 'http://169.254.169.254/latest/meta-data/'
-  PUPPET_FACTER_EC2_USERDATA_URL = 'http://169.254.169.254/latest/user-data/'
-
   config.around :each do |example|
-    # Ignore requests from Facter to external services
+    # Ignore requests from Facter GCE fact in Travis
     stub_request(:get, PUPPET_FACTER_2_GCE_URL)
     stub_request(:get, PUPPET_FACTER_3_GCE_URL)
-    stub_request(:get, PUPPET_FACTER_AZ_URL)
-    stub_request(:get, PUPPET_FACTER_EC2_METADATA_URL)
-    stub_request(:get, PUPPET_FACTER_EC2_USERDATA_URL)
 
     # Enable VCR if the example is tagged with `:vcr` metadata.
     if example.metadata[:vcr]

data/spec/unit/agent_spec.rb

@@ -3,13 +3,9 @@ require 'puppet/agent'
 require 'puppet/configurer'
 
 class AgentTestClient
-  def initialize(transaction_uuid = nil, job_id = nil)
-  end
-
-  def run(client_args)
+  def run
     # no-op
   end
-
   def stop
     # no-op
   end
@@ -24,8 +20,6 @@ end
 
 describe Puppet::Agent do
   before do
-    allow(Puppet::Status.indirection).to receive(:find).and_return(Puppet::Status.new("version" => Puppet.version))
-
     @agent = Puppet::Agent.new(AgentTestClient, false)
 
     # make Puppet::Application safe for stubbing; restore in an :after block; silence warnings for this.
@@ -38,10 +32,6 @@ describe Puppet::Agent do
         end
       end
     end
-
-    ssl_context = Puppet::SSL::SSLContext.new
-    machine = instance_double("Puppet::SSL::StateMachine", ensure_client_certificate: ssl_context)
-    allow(Puppet::SSL::StateMachine).to receive(:new).and_return(machine)
   end
 
   after do
@@ -59,10 +49,11 @@ describe Puppet::Agent do
 
   it "should create an instance of its client class and run it when asked to run" do
     client = double('client')
-    allow(AgentTestClient).to receive(:new).with(nil, nil).and_return(client)
+    expect(AgentTestClient).to receive(:new).and_return(client)
 
-    allow(@agent).to receive(:disabled?).and_return(false)
     expect(client).to receive(:run)
+
+    allow(@agent).to receive(:disabled?).and_return(false)
     @agent.run
   end
 
@@ -99,12 +90,11 @@ describe Puppet::Agent do
 
   describe "when being run" do
     before do
+      allow(AgentTestClient).to receive(:lockfile_path).and_return("/my/lock")
       allow(@agent).to receive(:disabled?).and_return(false)
     end
 
     it "should splay" do
-      Puppet[:splay] = true
-
       expect(@agent).to receive(:splay)
 
       @agent.run
@@ -187,26 +177,6 @@ describe Puppet::Agent do
       expect(@agent.run).to eq(:result)
     end
 
-    it "should check if it's disabled after splaying and log a message" do
-      Puppet[:splay] = true
-      Puppet[:splaylimit] = '5s'
-      Puppet[:onetime] = true
-
-      expect(@agent).to receive(:disabled?).and_return(false, true)
-
-      allow(Puppet).to receive(:notice).and_call_original
-      expect(Puppet).to receive(:notice).with(/Skipping run of .*; administratively disabled.*/)
-      @agent.run
-    end
-
-    it "should check if it's disabled after acquiring the lock and log a message" do
-      expect(@agent).to receive(:disabled?).and_return(false, true)
-
-      allow(Puppet).to receive(:notice).and_call_original
-      expect(Puppet).to receive(:notice).with(/Skipping run of .*; administratively disabled.*/)
-      @agent.run
-    end
-
     describe "and a puppet agent is already running" do
       before(:each) do
         allow_any_instance_of(Object).to receive(:sleep)
@@ -216,14 +186,14 @@ describe Puppet::Agent do
         allow(lockfile).to receive(:lock).and_return(false)
       end
 
-      it "should notify that a run is already in progress" do
+      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 progress and try to run every X seconds if waitforlock is used" do
+      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)
@@ -252,7 +222,7 @@ describe Puppet::Agent do
         @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)

data/spec/unit/application/agent_spec.rb

@@ -4,11 +4,6 @@ require 'puppet/agent'
 require 'puppet/application/agent'
 require 'puppet/daemon'
 
-class TestAgentClientClass
-  def initialize(transaction_uuid = nil, job_id = nil); end
-  def run(options = {}); end
-end
-
 describe Puppet::Application::Agent do
   include PuppetSpec::Files
 
@@ -17,20 +12,13 @@ describe Puppet::Application::Agent do
   before :each do
     @puppetd = Puppet::Application[:agent]
 
-    @client = TestAgentClientClass.new
-    allow(TestAgentClientClass).to receive(:new).and_return(@client)
-
-    @agent = Puppet::Agent.new(TestAgentClientClass, false)
+    @agent = double('agent')
     allow(Puppet::Agent).to receive(:new).and_return(@agent)
 
-    Puppet[:pidfile] = tmpfile('pidfile')
-    @daemon = Puppet::Daemon.new(@agent, Puppet::Util::Pidlock.new(Puppet[:pidfile]))
+    @daemon = Puppet::Daemon.new(@agent, nil)
     allow(@daemon).to receive(:daemonize)
+    allow(@daemon).to receive(:start)
     allow(@daemon).to receive(:stop)
-    # simulate one run so we don't infinite looptwo runs of the agent, then return so we don't infinite loop
-    allow(@daemon).to receive(:run_event_loop) do
-      @agent.run(splay: false)
-    end
     allow(Puppet::Daemon).to receive(:new).and_return(@daemon)
     Puppet[:daemonize] = false
 
@@ -104,6 +92,10 @@ describe Puppet::Application::Agent do
   end
 
   describe "when handling options" do
+    before do
+      allow(@puppetd.command_line).to receive(:args).and_return([])
+    end
+
     [:enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
       it "should declare handle_#{option} method" do
         expect(@puppetd).to respond_to("handle_#{option}".to_sym)
@@ -135,34 +127,32 @@ describe Puppet::Application::Agent do
     end
 
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
-      allow(@client).to receive(:run).and_return(2)
+      allow(@agent).to receive(:run).and_return(2)
       Puppet[:onetime] = true
 
-      expect(Puppet::SSL::StateMachine).to receive(:new).with(hash_including(waitforcert: 0)).and_return(machine)
+      expect(Puppet::SSL::StateMachine).to receive(:new).with(waitforcert: 0).and_return(machine)
 
       expect { execute_agent }.to exit_with 0
     end
 
     it "should use supplied waitforcert when --onetime is specified" do
-      allow(@client).to receive(:run).and_return(2)
+      allow(@agent).to receive(:run).and_return(2)
       Puppet[:onetime] = true
       @puppetd.handle_waitforcert(60)
 
-      expect(Puppet::SSL::StateMachine).to receive(:new).with(hash_including(waitforcert: 60)).and_return(machine)
+      expect(Puppet::SSL::StateMachine).to receive(:new).with(waitforcert: 60).and_return(machine)
 
       expect { execute_agent }.to exit_with 0
     end
 
     it "should use a default value for waitforcert when --onetime and --waitforcert are not specified" do
-      allow(@client).to receive(:run).and_return(2)
-
-      expect(Puppet::SSL::StateMachine).to receive(:new).with(hash_including(waitforcert: 120)).and_return(machine)
+      expect(Puppet::SSL::StateMachine).to receive(:new).with(waitforcert: 120).and_return(machine)
 
       execute_agent
     end
 
     it "should register ssl OIDs" do
-      expect(Puppet::SSL::StateMachine).to receive(:new).with(hash_including(waitforcert: 120)).and_return(machine)
+      expect(Puppet::SSL::StateMachine).to receive(:new).with(waitforcert: 120).and_return(double(ensure_client_certificate: nil))
       expect(Puppet::SSL::Oids).to receive(:register_puppet_oids)
 
       execute_agent
@@ -171,7 +161,7 @@ describe Puppet::Application::Agent do
     it "should use the waitforcert setting when checking for a signed certificate" do
       Puppet[:waitforcert] = 10
 
-      expect(Puppet::SSL::StateMachine).to receive(:new).with(hash_including(waitforcert: 10)).and_return(machine)
+      expect(Puppet::SSL::StateMachine).to receive(:new).with(waitforcert: 10).and_return(machine)
 
       execute_agent
     end
@@ -212,6 +202,7 @@ describe Puppet::Application::Agent do
       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)
     end
 
     it "should not run with extra arguments" do
@@ -423,9 +414,9 @@ describe Puppet::Application::Agent do
     end
 
     it "should wait for a certificate" do
-      Puppet[:waitforcert] = 123
+      @puppetd.options[:waitforcert] = 123
 
-      expect(Puppet::SSL::StateMachine).to receive(:new).with(hash_including(waitforcert: 123)).and_return(machine)
+      expect(Puppet::SSL::StateMachine).to receive(:new).with(waitforcert: 123).and_return(machine)
 
       execute_agent
     end
@@ -556,16 +547,11 @@ describe Puppet::Application::Agent do
         @puppetd.options[:digest] = :MD5
       end
 
-      def expected_fingerprint(name, x509)
-        digest = OpenSSL::Digest.new(name).hexdigest(x509.to_der)
-        digest.scan(/../).join(':').upcase
-      end
-
       it "should fingerprint the certificate if it exists" do
         cert = cert_fixture('signed.pem')
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_client_cert).and_return(cert)
 
-        expect(@puppetd).to receive(:puts).with("(MD5) #{expected_fingerprint('md5', cert)}")
+        expect(@puppetd).to receive(:puts).with('(MD5) E2:BA:9A:EF:20:A8:7D:10:8D:82:9A:61:5D:FD:5B:33')
 
         @puppetd.fingerprint
       end
@@ -575,7 +561,7 @@ describe Puppet::Application::Agent do
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_client_cert).and_return(nil)
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_request).and_return(request)
 
-        expect(@puppetd).to receive(:puts).with("(MD5) #{expected_fingerprint('md5', request)}")
+        expect(@puppetd).to receive(:puts).with('(MD5) B8:4C:FB:31:AE:17:86:E3:AD:53:97:CA:F6:3C:4A:CB')
 
         @puppetd.fingerprint
       end

data/spec/unit/application/apply_spec.rb

@@ -10,22 +10,21 @@ describe Puppet::Application::Apply do
 
   before :each do
     @apply = Puppet::Application[:apply]
+    allow(Puppet::Util::Log).to receive(:newdestination)
     Puppet[:reports] = "none"
   end
 
-  [:debug,:loadclasses,:test,:verbose,:use_nodes,:detailed_exitcodes,:catalog].each do |option|
+  [:debug,:loadclasses,:test,:verbose,:use_nodes,:detailed_exitcodes,:catalog, :write_catalog_summary].each do |option|
+    it "should declare handle_#{option} method" do
+      expect(@apply).to respond_to("handle_#{option}".to_sym)
+    end
+
     it "should store argument value when calling handle_#{option}" do
       expect(@apply.options).to receive(:[]=).with(option, 'arg')
       @apply.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
-  it "should handle write_catalog_summary" do
-    @apply.send(:handle_write_catalog_summary, true)
-
-    expect(Puppet[:write_catalog_summary]).to eq(true)
-  end
-
   it "should set the code to the provided code when :execute is used" do
     expect(@apply.options).to receive(:[]=).with(:code, 'arg')
     @apply.send("handle_execute".to_sym, 'arg')
@@ -54,18 +53,23 @@ describe Puppet::Application::Apply do
     end
 
     describe "with --test" do
+      it "should call setup_test" do
+        @apply.options[:test] = true
+        expect(@apply).to receive(:setup_test)
+
+        @apply.setup
+      end
+
       it "should set options[:verbose] to true" do
         @apply.setup_test
 
         expect(@apply.options[:verbose]).to eq(true)
       end
-
       it "should set options[:show_diff] to true" do
         Puppet.settings.override_default(:show_diff, false)
         @apply.setup_test
         expect(Puppet[:show_diff]).to eq(true)
       end
-
       it "should set options[:detailed_exitcodes] to true" do
         @apply.setup_test
 
@@ -151,7 +155,7 @@ describe Puppet::Application::Apply do
   end
 
   describe "when executing" do
-    it "should dispatch to 'apply' if it was called with a catalog" do
+    it "should dispatch to 'apply' if it was called with 'apply'" do
       @apply.options[:catalog] = "foo"
 
       expect(@apply).to receive(:apply)
@@ -209,52 +213,47 @@ describe Puppet::Application::Apply do
         @apply.options[:code] = "code to run"
         expect(Puppet).to receive(:[]=).with(:code,"code to run")
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should set the code to run from STDIN if no arguments" do
-        @apply.command_line.args = []
+        allow(@apply.command_line).to receive(:args).and_return([])
         allow(STDIN).to receive(:read).and_return("code to run")
 
         expect(Puppet).to receive(:[]=).with(:code,"code to run")
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
         noexist = tmpfile('noexist.pp')
-        @apply.command_line.args << noexist
-        expect {
-          @apply.run
-        }.to exit_with(1)
-         .and output(anything).to_stdout
-         .and output(/Could not find file #{noexist}/).to_stderr
+        allow(@apply.command_line).to receive(:args).and_return([noexist])
+        expect { @apply.main }.to raise_error(RuntimeError, "Could not find file #{noexist}")
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
         manifest = tmpfile('starwarsIV')
         FileUtils.touch(manifest)
 
-        @apply.command_line.args << manifest << 'starwarsI' << 'starwarsII'
-        expect {
-          @apply.run
-        }.to exit_with(0)
-         .and output(anything).to_stdout
-         .and output(/Warning: Only one file can be applied per run.  Skipping starwarsI, starwarsII/).to_stderr
+        allow(@apply.command_line).to receive(:args).and_return([manifest, 'starwarsI', 'starwarsII'])
+
+        expect { @apply.main }.to exit_with 0
+
+        msg = @logs.find {|m| m.message =~ /Only one file can be applied per run/ }
+        expect(msg.message).to eq('Only one file can be applied per run.  Skipping starwarsI, starwarsII')
+        expect(msg.level).to eq(:warning)
       end
 
       it "should splay" do
         expect(@apply).to receive(:splay)
 
-        expect {
-          @apply.run
-        }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
-      it "should exit with 1 if we can't find the node" do
+      it "should raise an error if we can't find the node" do
         expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
 
-        expect { @apply.run }.to exit_with(1).and output(/Could not find node/).to_stderr
+        expect { @apply.main }.to raise_error(RuntimeError, /Could not find node/)
       end
 
       it "should load custom classes if loadclasses" do
@@ -265,18 +264,18 @@ describe Puppet::Application::Apply do
 
         expect(@node).to receive(:classes=).with(['class'])
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should compile the catalog" do
         expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it 'should called the DeferredResolver to resolve any Deferred values' do
         expect(Puppet::Pops::Evaluator::DeferredResolver).to receive(:resolve_and_replace).with(any_args)
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it 'should make the Puppet::Pops::Loaders available when applying the compiled catalog' do
@@ -286,67 +285,47 @@ describe Puppet::Application::Apply do
           fail('Loaders not found') unless Puppet.lookup(:loaders) { nil }.is_a?(Puppet::Pops::Loaders)
           true
         end.and_return(0)
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should transform the catalog to ral" do
         expect(@catalog).to receive(:to_ral).and_return(@catalog)
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should finalize the catalog" do
         expect(@catalog).to receive(:finalize)
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should not save the classes or resource file by default" do
         expect(@catalog).not_to receive(:write_class_file)
         expect(@catalog).not_to receive(:write_resource_file)
-
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
-      it "should save the classes and resources files when requested on the command line using dashes" do
-        expect(@catalog).to receive(:write_class_file).once
-        expect(@catalog).to receive(:write_resource_file).once
-
-        # dashes are parsed by the application's OptionParser
-        @apply.command_line.args = ['--write-catalog-summary']
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
-      end
-
-      it "should save the classes and resources files when requested on the command line using underscores" do
-        expect(@catalog).to receive(:write_class_file).once
-        expect(@catalog).to receive(:write_resource_file).once
-
-        # underscores are parsed by the settings PuppetOptionParser
-        @apply.command_line.args = ['--write_catalog_summary']
-        Puppet.initialize_settings(['--write_catalog_summary'])
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
-      end
-
-      it "should save the classes and resources files when specified as a setting" do
-        Puppet[:write_catalog_summary] = true
+      it "should save the classes and resources files when requested" do
+        @apply.options[:write_catalog_summary] = true
 
         expect(@catalog).to receive(:write_class_file).once
         expect(@catalog).to receive(:write_resource_file).once
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
         expect_any_instance_of(Puppet::Configurer).to receive(:execute_prerun_command).and_return(true)
         expect_any_instance_of(Puppet::Configurer).to receive(:execute_postrun_command).and_return(true)
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should apply the catalog" do
         expect(@catalog).to receive(:apply).and_return(double('transaction'))
 
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should save the last run summary" do
@@ -355,7 +334,7 @@ describe Puppet::Application::Apply do
         allow(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
         expect_any_instance_of(Puppet::Configurer).to receive(:save_last_run_summary).with(report)
-        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+        expect { @apply.main }.to exit_with 0
       end
 
       describe "when using node_name_fact" do
@@ -368,27 +347,27 @@ describe Puppet::Application::Apply do
         end
 
         it "should set the facts name based on the node_name_fact" do
-          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+          expect { @apply.main }.to exit_with 0
           expect(@facts.name).to eq('other_node_name')
         end
 
         it "should set the node_name_value based on the node_name_fact" do
-          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+          expect { @apply.main }.to exit_with 0
           expect(Puppet[:node_name_value]).to eq('other_node_name')
         end
 
         it "should merge in our node the loaded facts" do
           @facts.values.merge!('key' => 'value')
 
-          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+          expect { @apply.main }.to exit_with 0
 
           expect(@node.parameters['key']).to eq('value')
         end
 
-        it "should exit if we can't find the facts" do
+        it "should raise an error if we can't find the facts" do
           expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(nil)
 
-          expect { @apply.run }.to exit_with(1).and output(/Could not find facts/).to_stderr
+          expect { @apply.main }.to raise_error(RuntimeError, /Could not find facts/)
         end
       end
 
@@ -401,14 +380,14 @@ describe Puppet::Application::Apply do
           Puppet[:noop] = false
           allow_any_instance_of(Puppet::Transaction::Report).to receive(:exit_status).and_return(666)
 
-          expect { @apply.run }.to exit_with(666).and output(anything).to_stdout
+          expect { @apply.main }.to exit_with 666
         end
 
         it "should exit with report's computed exit status, even if --noop is set" do
           Puppet[:noop] = true
           allow_any_instance_of(Puppet::Transaction::Report).to receive(:exit_status).and_return(666)
 
-          expect { @apply.run }.to exit_with(666).and output(anything).to_stdout
+          expect { @apply.main }.to exit_with 666
         end
 
         it "should always exit with 0 if option is disabled" do
@@ -416,7 +395,7 @@ describe Puppet::Application::Apply do
           report = double('report', :exit_status => 666)
           allow(@transaction).to receive(:report).and_return(report)
 
-          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+          expect { @apply.main }.to exit_with 0
         end
 
         it "should always exit with 0 if --noop" do
@@ -424,7 +403,7 @@ describe Puppet::Application::Apply do
           report = double('report', :exit_status => 666)
           allow(@transaction).to receive(:report).and_return(report)
 
-          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+          expect { @apply.main }.to exit_with 0
         end
       end
     end
@@ -524,15 +503,16 @@ describe Puppet::Application::Apply do
         }
       CODE
 
-      Puppet.settings[:write_catalog_summary] = true
+      @apply.options[:write_catalog_summary] = true
+
       Puppet.settings[:resourcefile] = resourcefile
       Puppet.settings[:classfile] = classfile
 
       #We don't actually need the resource to do anything, we are using it's properties in other parts of the workflow.
-      allow_any_instance_of(Puppet::Type.type(:exec).defaultprovider).to receive(:which).and_return('cat')
-      allow(Puppet::Util::Execution).to receive(:execute).and_return(double(exitstatus: 0, output: ''))
+      allow(Puppet::Util::Execution).to receive(:execute)
+
+      expect { @apply.main }.to exit_with 0
 
-      expect { @apply.run }.to exit_with(0).and output(%r{Exec\[do it\]/returns: executed successfully}).to_stdout
       result = File.read(resourcefile)
 
       expect(result).not_to match(/secret_file_name/)