puppet 6.17.0-x86-mingw32 → 6.21.0-x86-mingw32

data/spec/fixtures/unit/provider/package/puppetserver_gem/gem-list-local-packages

@@ -0,0 +1,30 @@
+concurrent-ruby (1.1.5)
+
+deep_merge (1.0.1)
+
+fast_gettext (1.1.2)
+
+gettext (3.2.2)
+
+hiera-eyaml (3.2.0)
+
+highline (1.6.21)
+
+hocon (1.3.1, 1.2.5)
+
+locale (2.1.3, 2.1.2)
+
+multi_json (1.14.1)
+
+optimist (3.0.1)
+
+puppet-resource_api (1.8.13)
+
+puppetserver-ca (1.8.0)
+
+semantic_puppet (1.0.2)
+
+text (1.3.1)
+
+world_airports (1.1.3)
+

data/spec/fixtures/unit/provider/user/aix/aix_passwd_file.out

@@ -6,6 +6,10 @@ test_aix_user:
 no_password_user:
         lastupdate = another_last_update
 
+tab_password_user:
+        password  =  some_password
+        lastupdate = another_last_update
+
 daemon:
         password = *
 

data/spec/integration/application/agent_spec.rb

@@ -15,21 +15,17 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
   let(:formatter) { Puppet::Network::FormatHandler.format(:rich_data_json) }
 
   context 'server_list' do
-    before :each do
-      Puppet[:log_level] = 'debug'
-    end
-
     it "uses the first server in the list" do
       Puppet[:server_list] = '127.0.0.1'
+      Puppet[:log_level] = 'debug'
 
       server.start_server do |port|
-        Puppet[:masterport] = port
+        Puppet[:serverport] = port
         expect {
-          expect {
-            agent.command_line.args << '--test'
-            agent.run
-          }.to exit_with(0)
-        }.to output(%r{HTTP GET https://127.0.0.1:#{port}/status/v1/simple/master returned 200 OK}).to_stdout
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(0)
+         .and output(%r{HTTP GET https://127.0.0.1:#{port}/status/v1/simple/master returned 200 OK}).to_stdout
       end
     end
 
@@ -37,16 +33,17 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
       Puppet[:server_list] = "puppet.example.com,#{Puppet[:server]}"
 
       server.start_server do |port|
-        Puppet[:masterport] = port
+        Puppet[:serverport] = port
         expect {
-          expect {
-            agent.command_line.args << '--test'
-            agent.run
-          }.to exit_with(0)
-        }.to output(%r{Unable to connect to server from server_list setting: Request to https://puppet.example.com:#{port}/status/v1/simple/master failed}).to_stdout
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(0)
+         .and output(%r{Notice: Applied catalog}).to_stdout
+         .and output(%r{Unable to connect to server from server_list setting: Request to https://puppet.example.com:#{port}/status/v1/simple/master failed}).to_stderr
 
         report = Puppet::Transaction::Report.convert_from(:yaml, File.read(Puppet[:lastrunreport]))
         expect(report.master_used).to eq("127.0.0.1:#{port}")
+        expect(report.server_used).to eq("127.0.0.1:#{port}")
       end
     end
 
@@ -54,36 +51,37 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
       Puppet[:server_list] = "puppet.example.com"
 
       expect {
-        expect {
-          expect {
-            agent.command_line.args << '--test'
-            agent.run
-          }.to exit_with(1)
-        }.to output(%r{Unable to connect to server from server_list setting: Could not select a functional puppet master from server_list: 'puppet.example.com'}).to_stdout
-      }.to output(/Error: Could not run Puppet configuration client: Could not select a functional puppet master from server_list: 'puppet.example.com'/).to_stderr
+        agent.command_line.args << '--test'
+        agent.run
+      }.to exit_with(1)
+       .and output(a_string_matching(%r{Unable to connect to server from server_list setting})
+       .and matching(/Error: Could not run Puppet configuration client: Could not select a functional puppet server from server_list: 'puppet.example.com'/)).to_stderr
 
       # I'd expect puppet to update the last run report even if the server_list was
       # exhausted, but it doesn't work that way currently, see PUP-6708
       expect(File).to_not be_exist(Puppet[:lastrunreport])
     end
 
-    it "omits master_used when not using server_list" do
+    it "omits server_used when not using server_list" do
+      Puppet[:log_level] = 'debug'
+
       server.start_server do |port|
-        Puppet[:masterport] = port
+        Puppet[:serverport] = port
         expect {
-          expect {
-            agent.command_line.args << '--test'
-            agent.run
-          }.to exit_with(0)
-        }.to output(%r{Resolved service 'puppet' to https://127.0.0.1:#{port}/puppet/v3}).to_stdout
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(0)
+         .and output(%r{Resolved service 'puppet' to https://127.0.0.1:#{port}/puppet/v3}).to_stdout
       end
 
       report = Puppet::Transaction::Report.convert_from(:yaml, File.read(Puppet[:lastrunreport]))
       expect(report.master_used).to be_nil
+      expect(report.server_used).to be_nil
     end
 
     it "server_list takes precedence over server" do
       Puppet[:server] = 'notvalid.example.com'
+      Puppet[:log_level] = 'debug'
 
       server.start_server do |port|
         Puppet[:server_list] = "127.0.0.1:#{port}"
@@ -96,15 +94,16 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
 
         report = Puppet::Transaction::Report.convert_from(:yaml, File.read(Puppet[:lastrunreport]))
         expect(report.master_used).to eq("127.0.0.1:#{port}")
+        expect(report.server_used).to eq("127.0.0.1:#{port}")
       end
     end
   end
 
   context 'rich data' do
-    it "applies deferred values" do
+    it "calls a deferred 4x function" do
       catalog_handler = -> (req, res) {
         catalog = compile_to_catalog(<<-MANIFEST, node)
-          notify { 'deferred':
+          notify { 'deferred4x':
             message => Deferred('join', [[1,2,3], ':'])
           }
         MANIFEST
@@ -114,13 +113,71 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
       }
 
       server.start_server(mounts: {catalog: catalog_handler}) do |port|
-        Puppet[:masterport] = port
+        Puppet[:serverport] = port
         expect {
-          expect {
-            agent.command_line.args << '--test'
-            agent.run
-          }.to exit_with(2)
-        }.to output(%r{Notice: /Stage\[main\]/Main/Notify\[deferred\]/message: defined 'message' as '1:2:3'}).to_stdout
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(2)
+         .and output(%r{Notice: /Stage\[main\]/Main/Notify\[deferred4x\]/message: defined 'message' as '1:2:3'}).to_stdout
+      end
+    end
+
+    it "calls a deferred 3x function" do
+      catalog_handler = -> (req, res) {
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+          notify { 'deferred3x':
+            message => Deferred('sprintf', ['%s', 'I am deferred'])
+          }
+        MANIFEST
+
+        res.body = formatter.render(catalog)
+        res['Content-Type'] = formatter.mime
+      }
+
+      server.start_server(mounts: {catalog: catalog_handler}) do |port|
+        Puppet[:serverport] = port
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(2)
+         .and output(%r{Notice: /Stage\[main\]/Main/Notify\[deferred3x\]/message: defined 'message' as 'I am deferred'}).to_stdout
+      end
+    end
+
+    it "re-evaluates a deferred function in a cached catalog" do
+      Puppet[:report] = false
+      Puppet[:use_cached_catalog] = true
+      Puppet[:usecacheonfailure] = false
+
+      catalog_dir = File.join(Puppet[:client_datadir], 'catalog')
+      Puppet::FileSystem.mkpath(catalog_dir)
+      cached_catalog_path = "#{File.join(catalog_dir, Puppet[:certname])}.json"
+
+      # our catalog contains a deferred function that calls `binary_file`
+      # to read `source`. The function returns a Binary object, whose
+      # base64 value is printed to stdout
+      source = tmpfile('deferred_source')
+      catalog = File.read(my_fixture('cached_deferred_catalog.json'))
+      catalog.gsub!('__SOURCE_PATH__', source)
+      File.write(cached_catalog_path, catalog)
+
+      # verify we get a different result each time the deferred function
+      # is evaluated, and reads `source`.
+      {
+        '1234' => 'MTIzNA==',
+        '5678' => 'NTY3OA=='
+      }.each_pair do |content, base64|
+        File.write(source, content)
+
+        expect {
+          agent.command_line.args << '-t'
+          agent.run
+
+        }.to exit_with(2)
+         .and output(/Notice: #{base64}/).to_stdout
+
+        # reset state so we can run again
+        Puppet::Application.clear!
       end
     end
 
@@ -137,13 +194,12 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
       }
 
       server.start_server(mounts: {catalog: catalog_handler}) do |port|
-        Puppet[:masterport] = port
+        Puppet[:serverport] = port
         expect {
-          expect {
-            agent.command_line.args << '--test'
-            agent.run
-          }.to exit_with(2)
-        }.to output(a_string_matching(
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(2)
+         .and output(a_string_matching(
           /Notice: Sensitive \[value redacted\]/
         ).and matching(
           /Notify\[sensitive\]\/message: changed \[redacted\] to \[redacted\]/
@@ -202,7 +258,7 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
       }
 
       server.start_server(mounts: {catalog: catalog_handler}) do |port|
-        Puppet[:masterport] = port
+        Puppet[:serverport] = port
         expect {
           expect {
             agent.command_line.args << '--test'
@@ -247,13 +303,12 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
       }
 
       server.start_server(mounts: mounts) do |port|
-        Puppet[:masterport] = port
+        Puppet[:serverport] = port
         expect {
-          expect {
-            agent.command_line.args << '--test'
-            agent.run
-          }.to exit_with(2)
-        }.to output(/content changed '{md5}d41d8cd98f00b204e9800998ecf8427e' to '{md5}4cf49285ae567157ebfba72bd04ccf32'/).to_stdout
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(2)
+         .and output(/content changed '{md5}d41d8cd98f00b204e9800998ecf8427e' to '{md5}4cf49285ae567157ebfba72bd04ccf32'/).to_stdout
 
         # verify puppet restored binary content
         expect(File.binread(path)).to eq(binary_content)
@@ -296,7 +351,7 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
         }
 
         server.start_server(mounts: {catalog: catalog_handler}) do |puppetserver_port|
-          Puppet[:masterport] = puppetserver_port
+          Puppet[:serverport] = puppetserver_port
 
           # override path to system cacert bundle, this must be done before
           # the SSLContext is created and the call to X509::Store.set_default_paths
@@ -348,7 +403,7 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
         }
 
         server.start_server(mounts: {catalog: catalog_handler}) do |puppetserver_port|
-          Puppet[:masterport] = puppetserver_port
+          Puppet[:serverport] = puppetserver_port
 
           # override path to system cacert bundle, this must be done before
           # the SSLContext is created and the call to X509::Store.set_default_paths
@@ -399,7 +454,7 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
         }
 
         server.start_server(mounts: {catalog: catalog_handler}) do |puppetserver_port|
-          Puppet[:masterport] = puppetserver_port
+          Puppet[:serverport] = puppetserver_port
 
           # set path to external cacert bundle, this must be done before
           # the SSLContext is created
@@ -439,7 +494,7 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
     it "waits for other agent run to finish before starting" do
       server.start_server do |port|
         path = Puppet[:agent_catalog_run_lockfile]
-        Puppet[:masterport] = port
+        Puppet[:serverport] = port
         Puppet[:waitforlock] = 1
 
         th = Thread.new {
@@ -480,4 +535,102 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
       th.kill # kill thread so we don't wait too much
     end
   end
+
+  context 'cached catalogs' do
+    it 'falls back to a cached catalog' do
+      catalog_handler = -> (req, res) {
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+          notify { 'a message': }
+        MANIFEST
+
+        res.body = formatter.render(catalog)
+        res['Content-Type'] = formatter.mime
+      }
+
+      server.start_server(mounts: {catalog: catalog_handler}) do |port|
+        Puppet[:serverport] = port
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(2)
+         .and output(%r{Caching catalog for #{Puppet[:certname]}}).to_stdout
+      end
+
+      # reset state so we can run again
+      Puppet::Application.clear!
+
+      # --test above turns off `usecacheonfailure` so re-enable here
+      Puppet[:usecacheonfailure] = true
+
+      # run agent without server
+      expect {
+        agent.command_line.args << '--no-daemonize' << '--onetime' << '--server' << '127.0.0.1'
+        agent.run
+      }.to exit_with(2)
+       .and output(a_string_matching(
+         /Using cached catalog from environment 'production'/
+       ).and matching(
+         /Notify\[a message\]\/message:/
+       )).to_stdout
+       .and output(/the agent run will continue/).to_stderr
+    end
+
+    it 'preserves the old cached catalog if validation fails with the old one' do
+      catalog_handler = -> (req, res) {
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+          exec { 'unqualified_command': }
+        MANIFEST
+
+        res.body = formatter.render(catalog)
+        res['Content-Type'] = formatter.mime
+      }
+
+      server.start_server(mounts: {catalog: catalog_handler}) do |port|
+        Puppet[:serverport] = port
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(1)
+         .and output(/Using configured environment/).to_stdout
+         .and output(%r{Validation of Exec\[unqualified_command\] failed: 'unqualified_command' is not qualified and no path was specified}).to_stderr
+      end
+
+      # cached catalog should not be updated
+      cached_catalog = "#{File.join(Puppet[:client_datadir], 'catalog', Puppet[:certname])}.json"
+      expect(File).to_not be_exist(cached_catalog)
+    end
+  end
+
+  context "reporting" do
+    it "stores a finalized report" do
+      catalog_handler = -> (req, res) {
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+        notify { 'foo':
+          require => Notify['bar']
+        }
+
+        notify { 'bar':
+          require => Notify['foo']
+        }
+        MANIFEST
+
+        res.body = formatter.render(catalog)
+        res['Content-Type'] = formatter.mime
+      }
+
+      server.start_server(mounts: {catalog: catalog_handler}) do |port|
+        Puppet[:serverport] = port
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(1)
+         .and output(%r{Applying configuration}).to_stdout
+         .and output(%r{Found 1 dependency cycle}).to_stderr
+
+        report = Puppet::Transaction::Report.convert_from(:yaml, File.read(Puppet[:lastrunreport]))
+        expect(report.status).to eq("failed")
+        expect(report.metrics).to_not be_empty
+      end
+    end
+  end
 end

data/spec/integration/application/apply_spec.rb

@@ -6,6 +6,8 @@ require 'puppet_spec/https'
 describe "apply", unless: Puppet::Util::Platform.jruby? do
   include PuppetSpec::Files
 
+  let(:apply) { Puppet::Application[:apply] }
+
   before :each do
     Puppet[:reports] = "none"
     # Let exceptions be raised instead of exiting
@@ -19,76 +21,51 @@ describe "apply", unless: Puppet::Util::Platform.jruby? do
       resource = Puppet::Resource.new(:file, file_to_create, :parameters => {:content => "my stuff"})
       catalog.add_resource resource
 
-      manifest = file_containing("manifest", catalog.to_json)
-
-      puppet = Puppet::Application[:apply]
-      puppet.options[:catalog] = manifest
-
-      puppet.apply
+      apply.command_line.args = ['--catalog', file_containing("manifest", catalog.to_json)]
+      expect {
+        apply.run
+      }.to output(/ensure: defined content as/).to_stdout
 
       expect(Puppet::FileSystem.exist?(file_to_create)).to be_truthy
       expect(File.read(file_to_create)).to eq("my stuff")
     end
 
-    context 'from environment with a pcore defined resource type' do
-      include PuppetSpec::Compiler
-
-      let!(:envdir) { tmpdir('environments') }
+    context 'and pcore types are available' do
+      let(:envdir) { my_fixture('environments') }
       let(:env_name) { 'spec' }
-      let(:dir_structure) {
-        {
-          '.resource_types' => {
-            'applytest.pp' => <<-CODE
-            Puppet::Resource::ResourceType3.new(
-              'applytest',
-              [Puppet::Resource::Param.new(String, 'message')],
-              [Puppet::Resource::Param.new(String, 'name', true)])
-          CODE
-          },
-          'modules' => {
-            'amod' => {
-              'lib' => {
-                'puppet' => {
-                  'type' => { 'applytest.rb' => <<-CODE
-Puppet::Type.newtype(:applytest) do
-newproperty(:message) do
-  def sync
-    Puppet.send(@resource[:loglevel], self.should)
-  end
 
-  def retrieve
-    :absent
-  end
+      before(:each) do
+        Puppet[:environmentpath] = envdir
+        Puppet[:environment] = env_name
+      end
 
-  def insync?(is)
-    false
-  end
+      it 'does not load the pcore type' do
+        apply = Puppet::Application[:apply]
+        apply.command_line.args = [ '-e', "Applytest { message => 'the default'} applytest { 'applytest was here': }" ]
 
-  defaultto { @resource[:name] }
-end
+        expect {
+          apply.run
+        }.to exit_with(0)
+         .and output(a_string_matching(
+           /the Puppet::Type says hello/
+         ).and matching(
+           /applytest was here/
+         )).to_stdout
+      end
+    end
 
-newparam(:name) do
-  desc "An arbitrary tag for your own reference; the name of the message."
-  Puppet.notice('the Puppet::Type says hello')
-  isnamevar
-end
-end
-                  CODE
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
+    context 'from environment with a pcore defined resource type' do
+      include PuppetSpec::Compiler
 
+      let(:envdir) { my_fixture('environments') }
+      let(:env_name) { 'spec' }
       let(:environments) { Puppet::Environments::Directories.new(envdir, []) }
       let(:env) { Puppet::Node::Environment.create(:'spec', [File.join(envdir, 'spec', 'modules')]) }
       let(:node) { Puppet::Node.new('test', :environment => env) }
+
       around(:each) do |example|
         Puppet::Type.rmtype(:applytest)
         Puppet[:environment] = env_name
-        dir_contained_in(envdir, env_name => dir_structure)
         Puppet.override(:environments => environments, :current_environment => env) do
           example.run
         end
@@ -96,12 +73,13 @@ end
 
       it 'does not load the pcore type' do
         catalog = compile_to_catalog('applytest { "applytest was here":}', node)
-        apply = Puppet::Application[:apply]
-        apply.options[:catalog] = file_containing('manifest', catalog.to_json)
+        apply.command_line.args = ['--catalog', file_containing('manifest', catalog.to_json)]
 
         Puppet[:environmentpath] = envdir
         expect_any_instance_of(Puppet::Pops::Loader::Runtime3TypeLoader).not_to receive(:find)
-        expect { apply.run }.to have_printed(/the Puppet::Type says hello.*applytest was here/m)
+        expect {
+          apply.run
+        }.to output(/the Puppet::Type says hello.*applytest was here/m).to_stdout
       end
 
       # Test just to verify that the Pcore Resource Type and not the Ruby one is produced when the catalog is produced
@@ -113,7 +91,9 @@ end
 
         expect(compiler.loaders.runtime3_type_loader.instance_variable_get(:@resource_3x_loader)).to receive(:set_entry).once.with(tn, rt, instance_of(String))
           .and_return(Puppet::Pops::Loader::Loader::NamedEntry.new(tn, rt, nil))
-        expect { compiler.compile }.not_to have_printed(/the Puppet::Type says hello/)
+        expect {
+          compiler.compile
+        }.not_to output(/the Puppet::Type says hello/).to_stdout
       end
 
       it "does not fail when pcore type is loaded twice" do
@@ -226,36 +206,36 @@ end
       catalog = compile_to_catalog('include mod', node)
 
       Puppet[:environment] = env_name
-      apply = Puppet::Application[:apply]
-      apply.options[:catalog] = file_containing('manifest', catalog.to_json)
-      expect { apply.run_command; exit(0) }.to exit_with(0)
-      expect(@logs.map(&:to_s)).to include('The Street 23')
+      apply.command_line.args = ['--catalog', file_containing('manifest', catalog.to_json)]
+
+      expect {
+        apply.run
+      }.to output(%r{Notify\[The Street 23\]/message: defined 'message' as 'The Street 23'}).to_stdout
     end
   end
 
-  it "applies a given file even when a directory environment is specified" do
+  it "raises if the environment directory does not exist" do
     manifest = file_containing("manifest.pp", "notice('it was applied')")
+    apply.command_line.args = [manifest]
 
     special = Puppet::Node::Environment.create(:special, [])
     Puppet.override(:current_environment => special) do
       Puppet[:environment] = 'special'
-      puppet = Puppet::Application[:apply]
-      allow(puppet).to receive(:command_line).and_return(double('command_line', :args => [manifest]))
-      expect { puppet.run_command }.to exit_with(0)
+      expect {
+        apply.run
+      }.to raise_error(Puppet::Environments::EnvironmentNotFound,
+                       /Could not find a directory environment named 'special' anywhere in the path/)
     end
-
-    expect(@logs.map(&:to_s)).to include('it was applied')
   end
 
   it "adds environment to the $server_facts variable" do
     manifest = file_containing("manifest.pp", "notice(\"$server_facts\")")
+    apply.command_line.args = [manifest]
 
-    puppet = Puppet::Application[:apply]
-    allow(puppet).to receive(:command_line).and_return(double('command_line', :args => [manifest]))
-
-    expect { puppet.run_command }.to exit_with(0)
-
-    expect(@logs.map(&:to_s)).to include(/{environment =>.*/)
+    expect {
+      apply.run
+    }.to exit_with(0)
+     .and output(/{environment => production}/).to_stdout
   end
 
   it "applies a given file even when an ENC is configured", :unless => Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
@@ -271,48 +251,36 @@ end
       Puppet[:environment] = 'special'
       Puppet[:node_terminus] = 'exec'
       Puppet[:external_nodes] = enc
-      puppet = Puppet::Application[:apply]
-      allow(puppet).to receive(:command_line).and_return(double('command_line', :args => [manifest]))
-      expect { puppet.run_command }.to exit_with(0)
+      apply.command_line.args = [manifest]
+      expect {
+        apply.run
+      }.to exit_with(0)
+       .and output(/Notice: Scope\(Class\[main\]\): specific manifest applied/).to_stdout
     end
-
-    expect(@logs.map(&:to_s)).to include('specific manifest applied')
   end
 
   context "handles errors" do
     it "logs compile errors once" do
-      Puppet.initialize_settings([])
-      apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => []))
-      apply.options[:code] = '08'
-
-      msg = 'valid octal'
-      callback = Proc.new do |actual|
-        expect(actual.scan(Regexp.new(msg))).to eq([msg])
-      end
-
-      expect do
+      apply.command_line.args = ['-e', '08']
+      expect {
         apply.run
-      end.to have_printed(callback).and_exit_with(1)
+      }.to exit_with(1)
+       .and output(/Not a valid octal number/).to_stderr
     end
 
     it "logs compile post processing errors once" do
-      Puppet.initialize_settings([])
-      apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => []))
       path = File.expand_path('/tmp/content_file_test.Q634Dlmtime')
-      apply.options[:code] = "file { '#{path}':
+      apply.command_line.args = ['-e', "file { '#{path}':
         content => 'This is the test file content',
         ensure => present,
         checksum => mtime
-      }"
-
-      msg = 'You cannot specify content when using checksum'
-      callback = Proc.new do |actual|
-        expect(actual.scan(Regexp.new(msg))).to eq([msg])
-      end
+      }"]
 
-      expect do
+      expect {
         apply.run
-      end.to have_printed(callback).and_exit_with(1)
+      }.to exit_with(1)
+       .and output(/Compiled catalog/).to_stdout
+       .and output(/You cannot specify content when using checksum/).to_stderr
     end
   end
 
@@ -337,51 +305,42 @@ end
       Puppet[:environmentpath] = envdir
     end
 
-    def init_cli_args_and_apply_app(args, execute)
-      Puppet.initialize_settings(args)
-      puppet = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => args))
-      puppet.options[:code] = execute
-      return puppet
-    end
+    context "given a modulepath" do
+      let(:args) { ['-e', execute] }
 
-    context "given the --modulepath option" do
-      let(:args) { ['-e', execute, '--modulepath', modulepath] }
+      before :each do
+        Puppet[:modulepath] = modulepath
 
-      it "looks in --modulepath even when the default directory environment exists" do
-        apply = init_cli_args_and_apply_app(args, execute)
+        apply.command_line.args = args
+      end
 
-        expect do
-          expect { apply.run }.to exit_with(0)
-        end.to have_printed('amod class included')
+      it "looks in modulepath even when the default directory environment exists" do
+        expect {
+          apply.run
+        }.to exit_with(0)
+         .and output(/amod class included/).to_stdout
       end
 
-      it "looks in --modulepath even when given a specific directory --environment" do
-        args << '--environment' << 'production'
-        apply = init_cli_args_and_apply_app(args, execute)
+      it "looks in modulepath even when given a specific directory --environment" do
+        apply.command_line.args = args << '--environment' << 'production'
 
-        expect do
-          expect { apply.run }.to exit_with(0)
-        end.to have_printed('amod class included')
+        expect {
+          apply.run
+        }.to exit_with(0)
+         .and output(/amod class included/).to_stdout
       end
 
-      it "looks in --modulepath when given multiple paths in --modulepath" do
-        args = ['-e', execute, '--modulepath', [tmpdir('notmodulepath'), modulepath].join(File::PATH_SEPARATOR)]
-        apply = init_cli_args_and_apply_app(args, execute)
+      it "looks in modulepath when given multiple paths in modulepath" do
+        Puppet[:modulepath] = [tmpdir('notmodulepath'), modulepath].join(File::PATH_SEPARATOR)
 
-        expect do
-          expect { apply.run }.to exit_with(0)
-        end.to have_printed('amod class included')
+        expect {
+          apply.run
+        }.to exit_with(0)
+         .and output(/amod class included/).to_stdout
       end
     end
 
-    # When executing an ENC script, output cannot be captured using
-    # expect { }.to have_printed(...)
-    # External node script execution will fail, likely due to the tampering
-    # with the basic file descriptors.
-    # Workaround: Define a log destination and merely inspect logs.
     context "with an ENC" do
-      let(:logdest) { tmpfile('logdest') }
-      let(:args) { ['-e', execute, '--logdest', logdest ] }
       let(:enc) do
         script_containing('enc_script',
           :windows => '@echo environment: spec',
@@ -394,17 +353,23 @@ end
       end
 
       it "should use the environment that the ENC mandates" do
-        apply = init_cli_args_and_apply_app(args, execute)
-        expect { apply.run }.to exit_with(0)
-        expect(@logs.map(&:to_s)).to include('amod class included')
+        apply.command_line.args = ['-e', execute]
+
+        expect {
+          apply.run
+       }.to exit_with(0)
+        .and output(a_string_matching(/amod class included/)
+        .and matching(/Compiled catalog for .* in environment spec/)).to_stdout
       end
 
       it "should prefer the ENC environment over the configured one and emit a warning" do
-        apply = init_cli_args_and_apply_app(args + [ '--environment', 'production' ], execute)
-        expect { apply.run }.to exit_with(0)
-        logs = @logs.map(&:to_s)
-        expect(logs).to include('amod class included')
-        expect(logs).to include(match(/doesn't match server specified environment/))
+        apply.command_line.args = ['-e', execute, '--environment', 'production']
+
+        expect {
+          apply.run
+        }.to exit_with(0)
+         .and output(a_string_matching('amod class included')
+         .and matching(/doesn't match server specified environment/)).to_stdout
       end
     end
   end
@@ -475,8 +440,7 @@ class amod::bad_type {
     context 'and the file is not serialized with rich_data' do
       it 'will notify a string that is the result of Regexp#inspect (from Runtime3xConverter)' do
         catalog = compile_to_catalog(execute, node)
-        apply = Puppet::Application[:apply]
-        apply.options[:catalog] = file_containing('manifest', catalog.to_json)
+        apply.command_line.args = ['--catalog', file_containing('manifest', catalog.to_json)]
         expect(apply).to receive(:apply_catalog) do |cat|
           expect(cat.resource(:notify, 'rx')['message']).to be_a(String)
           expect(cat.resource(:notify, 'bin')['message']).to be_a(String)
@@ -491,8 +455,7 @@ class amod::bad_type {
 
       it 'will notify a string that is the result of to_s on uknown data types' do
         json = compile_to_catalog('include amod::bad_type', node).to_json
-        apply = Puppet::Application[:apply]
-        apply.options[:catalog] = file_containing('manifest', json)
+        apply.command_line.args = ['--catalog', file_containing('manifest', json)]
         expect(apply).to receive(:apply_catalog) do |catalog|
           expect(catalog.resource(:notify, 'bogus')['message']).to be_a(String)
         end
@@ -514,11 +477,10 @@ class amod::bad_type {
     context 'and the file is serialized with rich_data' do
       it 'will notify a regexp using Regexp#to_s' do
         catalog = compile_to_catalog(execute, node)
-        apply = Puppet::Application[:apply]
         serialized_catalog = Puppet.override(rich_data: true) do
           catalog.to_json
         end
-        apply.options[:catalog] = file_containing('manifest', serialized_catalog)
+        apply.command_line.args = ['--catalog', file_containing('manifest', serialized_catalog)]
         expect(apply).to receive(:apply_catalog) do |cat|
           expect(cat.resource(:notify, 'rx')['message']).to be_a(Regexp)
           # The resource return in this expect is a String, but since it was a Binary type that
@@ -541,7 +503,6 @@ class amod::bad_type {
     let(:env_dir) { File.join(Puppet[:environmentpath], env_name) }
     let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(env_dir, 'modules')]) }
     let(:node) { Puppet::Node.new(Puppet[:certname], environment: environment) }
-    let(:apply) { Puppet::Application[:apply] }
 
     before :each do
       Puppet[:environment] = env_name
@@ -564,7 +525,7 @@ class amod::bad_type {
 
       expect {
         apply.command_line.args << manifest
-         apply.run
+        apply.run
       }.to exit_with(0)
        .and output(a_string_matching(
          /dir1\]\/ensure: created/
@@ -579,6 +540,46 @@ class amod::bad_type {
     end
   end
 
+  context 'http file sources' do
+    include_context 'https client'
+
+    it "requires the caller to URL encode special characters in the request path and query" do
+      Puppet[:server] = '127.0.0.1'
+      request = nil
+
+      response_proc = -> (req, res) {
+        request = req
+
+        res['Content-Type'] = 'text/plain'
+        res.body = "from the server"
+      }
+
+      https = PuppetSpec::HTTPSServer.new
+      https.start_server(response_proc: response_proc) do |https_port|
+        dest = tmpfile('http_file_source')
+
+        # spaces in path are encoded as %20 and '[' in query is encoded as %5B,
+        # but ':', '=', '-' are not encoded
+        manifest = file_containing("manifest.pp", <<~MANIFEST)
+          file { "#{dest}":
+            ensure  => file,
+            source  => "https://#{Puppet[:server]}:#{https_port}/path%20to%20file?x=b%5Bc&sv=2019-02-02&st=2020-07-28T20:18:53Z&se=2020-07-28T21:03:00Z&sr=b&sp=r&sig=JaZhcqxT4akJcOwUdUGrQB2m1geUoh89iL8WMag8a8c=",
+          }
+        MANIFEST
+
+        expect {
+          apply.command_line.args << manifest
+          apply.run
+        }.to exit_with(0)
+         .and output(%r{Main/File\[#{dest}\]/ensure: defined content as}).to_stdout
+
+        expect(request.path).to eq('/path to file')
+        expect(request.query).to include('x' => 'b[c')
+        expect(request.query).to include('sig' => 'JaZhcqxT4akJcOwUdUGrQB2m1geUoh89iL8WMag8a8c=')
+      end
+    end
+  end
+
   context 'http report processor' do
     include_context 'https client'
 
@@ -586,7 +587,6 @@ class amod::bad_type {
       Puppet[:reports] = 'http'
     end
 
-    let(:apply) { Puppet::Application[:apply] }
     let(:unknown_server) do
       unknown_ca_cert = cert_fixture('unknown-ca.pem')
       PuppetSpec::HTTPSServer.new(
@@ -663,4 +663,23 @@ class amod::bad_type {
       end
     end
   end
+
+  context 'rich data' do
+    it "calls a deferred 4x function" do
+      apply.command_line.args = ['-e', 'notify { "deferred3x": message => Deferred("join", [[1,2,3], ":"]) }']
+
+      expect {
+        apply.run
+      }.to exit_with(0) # for some reason apply returns 0 instead of 2
+       .and output(%r{Notice: /Stage\[main\]/Main/Notify\[deferred3x\]/message: defined 'message' as '1:2:3'}).to_stdout
+    end
+
+    it "calls a deferred 3x function" do
+      apply.command_line.args = ['-e', 'notify { "deferred4x": message => Deferred("sprintf", ["%s", "I am deferred"]) }']
+      expect {
+        apply.run
+      }.to exit_with(0) # for some reason apply returns 0 instead of 2
+       .and output(%r{Notice: /Stage\[main\]/Main/Notify\[deferred4x\]/message: defined 'message' as 'I am deferred'}).to_stdout
+    end
+  end
 end