puppet 6.26.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/lib/matchers/include.rb

@@ -0,0 +1,27 @@
+module Matchers; module Include
+  extend RSpec::Matchers::DSL
+
+  matcher :include_in_any_order do |*matchers|
+    match do |enumerable|
+      @not_matched = []
+      expected_as_array.each do |matcher|
+        if enumerable.empty?
+          break
+        end
+
+        if found = enumerable.find { |elem| matcher.matches?(elem) }
+          enumerable = enumerable.reject { |elem| elem == found }
+        else
+          @not_matched << matcher
+        end
+      end
+
+
+      @not_matched.empty? && enumerable.empty?
+    end
+
+    failure_message do |enumerable|
+      "did not match #{@not_matched.collect(&:description).join(', ')} in #{enumerable.inspect}: <#{@not_matched.collect(&:failure_message).join('>, <')}>"
+    end
+  end
+end; end

data/spec/lib/matchers/include_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'matchers/include'
+
+describe "include matchers" do
+  include Matchers::Include
+
+  context :include_in_any_order do
+    it "matches an empty list" do
+      expect([]).to include_in_any_order()
+    end
+
+    it "matches a list with a single element" do
+      expect([1]).to include_in_any_order(eq(1))
+    end
+
+    it "does not match when an expected element is missing" do
+      expect([1]).to_not include_in_any_order(eq(2))
+    end
+
+    it "matches a list with 2 elements in a different order from the expectation" do
+      expect([1, 2]).to include_in_any_order(eq(2), eq(1))
+    end
+
+    it "does not match when there are more than just the expected elements" do
+      expect([1, 2]).to_not include_in_any_order(eq(1))
+    end
+
+    it "matches multiple, equal elements when there are multiple, equal exepectations" do
+      expect([1, 1]).to include_in_any_order(eq(1), eq(1))
+    end
+  end
+end

data/spec/lib/puppet/test_ca.rb

@@ -30,7 +30,7 @@ module Puppet
     end
 
     def create_request(name)
-      key = OpenSSL::PKey::RSA.new(2048)
+      key = OpenSSL::PKey::RSA.new(1024)
       csr = OpenSSL::X509::Request.new
       csr.public_key = key.public_key
       csr.subject = OpenSSL::X509::Name.new([["CN", name]])
@@ -46,11 +46,6 @@ module Puppet
         ext = ef.create_extension(["subjectAltName", opts[:subject_alt_names], false])
         cert.add_extension(ext)
       end
-      if exts = opts[:extensions]
-        exts.each do |e|
-          cert.add_extension(OpenSSL::X509::Extension.new(*e))
-        end
-      end
       cert.sign(issuer_key, @digest)
       { private_key: key, cert: cert }
     end
@@ -132,7 +127,7 @@ module Puppet
       key = if opts[:key_type] == :ec
               key = OpenSSL::PKey::EC.generate('prime256v1')
             else
-              key = OpenSSL::PKey::RSA.new(2048)
+              key = OpenSSL::PKey::RSA.new(1024)
             end
       cert = OpenSSL::X509::Certificate.new
       cert.public_key = if key.is_a?(OpenSSL::PKey::EC)

data/spec/lib/puppet_spec/modules.rb

@@ -36,7 +36,7 @@ module PuppetSpec::Modules
         end
       end
 
-      if (plans = options[:plans])
+      if plans = options[:plans]
         plans_dir = File.join(module_dir, 'plans')
         FileUtils.mkdir_p(plans_dir)
         plans.each do |plan_file|
@@ -48,17 +48,6 @@ module PuppetSpec::Modules
         end
       end
 
-      if (scripts = options[:scripts])
-        scripts_dir = File.join(module_dir, 'scripts')
-        FileUtils.mkdir_p(scripts_dir)
-        scripts.each do |script_file|
-          if script_file.is_a?(String)
-            script_file = { :name => script_file, :content => "" }
-          end
-          File.write(File.join(scripts_dir, script_file[:name]), script_file[:content])
-        end
-      end
-
       (options[:files] || {}).each do |fname, content|
         path = File.join(module_dir, fname)
         FileUtils.mkdir_p(File.dirname(path))
@@ -72,7 +61,7 @@ module PuppetSpec::Modules
       module_dir = File.join(dir, name)
       FileUtils.mkdir_p(module_dir)
 
-      if (metadata = options[:metadata])
+      if metadata = options[:metadata]
         File.open(File.join(module_dir, 'metadata.json'), 'w') do |f|
           f.write(metadata.to_json)
         end

data/spec/lib/puppet_spec/puppetserver.rb

@@ -31,19 +31,6 @@ class PuppetSpec::Puppetserver
     end
   end
 
-  class FileMetadataServlet < WEBrick::HTTPServlet::AbstractServlet
-    def do_GET request, response
-      response['Content-Type'] = 'application/json'
-      response.body = "{\"path\":\"/etc/puppetlabs/code/environments/production/modules\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-03-06 20:14:25 UTC\"},\"type\":\"directory\",\"destination\":null}"
-    end
-  end
-
-  class FileContentServlet < WEBrick::HTTPServlet::AbstractServlet
-    def do_GET request, response
-      response.status = 404
-    end
-  end
-
   class ReportServlet < WEBrick::HTTPServlet::AbstractServlet
     def do_PUT request, response
       response['Content-Type'] = 'application/json'
@@ -116,12 +103,10 @@ class PuppetSpec::Puppetserver
   end
 
   def register_mounts(mounts: {})
-    register_mount('/status/v1/simple/master', proc { |req, res|  }, nil)
+    register_mount('/status/v1/simple/server', proc { |req, res|  }, nil)
     register_mount('/puppet/v3/node', mounts[:node], NodeServlet)
     register_mount('/puppet/v3/catalog', mounts[:catalog], CatalogServlet)
-    register_mount('/puppet/v3/file_metadata', mounts[:file_metadata], FileMetadataServlet)
     register_mount('/puppet/v3/file_metadatas', mounts[:file_metadatas], FileMetadatasServlet)
-    register_mount('/puppet/v3/file_content', mounts[:file_content], FileContentServlet)
     register_mount('/puppet/v3/static_file_content', mounts[:static_file_content], StaticFileContentServlet)
     register_mount('/puppet/v3/report', mounts[:report], ReportServlet)
     register_mount('/puppet/v3/file_bucket_file', mounts[:filebucket], FilebucketServlet)

data/spec/lib/puppet_spec/settings.rb

@@ -11,6 +11,7 @@ module PuppetSpec::Settings
     :confdir      => { :type => :directory, :default => "test", :desc => "confdir" },
     :codedir      => { :type => :directory, :default => "test", :desc => "codedir" },
     :vardir       => { :type => :directory, :default => "test", :desc => "vardir" },
+    :publicdir    => { :type => :directory, :default => "test", :desc => "publicdir" },
     :rundir       => { :type => :directory, :default => "test", :desc => "rundir" },
   }.freeze
 
@@ -20,7 +21,6 @@ module PuppetSpec::Settings
   end.freeze
 
   def set_puppet_conf(confdir, settings)
-    FileUtils.mkdir_p(confdir)
     write_file(File.join(confdir, "puppet.conf"), settings)
   end
 

data/spec/shared_behaviours/documentation_on_faces.rb

@@ -176,6 +176,8 @@ shared_examples_for "documentation on faces" do
       subject.license = "foo"
       expect(subject.license).to eq("foo")
     end
+
+    it "should accept symbols to specify existing licenses..."
   end
 
   describe "#copyright" do

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.
@@ -55,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
 
@@ -95,6 +90,7 @@ 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
 
@@ -190,7 +186,7 @@ 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/)

data/spec/unit/application/agent_spec.rb

@@ -202,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
@@ -546,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
@@ -565,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/)