puppet 6.11.1-x86-mingw32 → 6.16.0-x86-mingw32

data/spec/unit/application/apply_spec.rb

@@ -14,14 +14,6 @@ describe Puppet::Application::Apply do
     Puppet[:reports] = "none"
   end
 
-  after :each do
-    Puppet::Node::Facts.indirection.reset_terminus_class
-    Puppet::Node::Facts.indirection.cache_class = nil
-
-    Puppet::Node.indirection.reset_terminus_class
-    Puppet::Node.indirection.cache_class = nil
-  end
-
   [: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)
@@ -182,13 +174,11 @@ describe Puppet::Application::Apply do
         Puppet[:prerun_command] = ''
         Puppet[:postrun_command] = ''
 
-        Puppet::Node::Facts.indirection.terminus_class = :memory
-        Puppet::Node::Facts.indirection.cache_class = :memory
         Puppet::Node.indirection.terminus_class = :memory
         Puppet::Node.indirection.cache_class = :memory
 
-        @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
-        Puppet::Node::Facts.indirection.save(@facts)
+        facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
+        Puppet::Node::Facts.indirection.save(facts)
 
         @node = Puppet::Node.new(Puppet[:node_name_value])
         Puppet::Node.indirection.save(@node)

data/spec/unit/application/describe_spec.rb

@@ -3,95 +3,133 @@ require 'spec_helper'
 require 'puppet/application/describe'
 
 describe Puppet::Application::Describe do
-  before :each do
-    @describe = Puppet::Application[:describe]
-  end
+  let(:describe) { Puppet::Application[:describe] }
+
+  it "lists all types" do
+    describe.command_line.args << '--list'
 
-  it "should declare a main command" do
-    expect(@describe).to respond_to(:main)
+    expect {
+      describe.run
+    }.to output(/These are the types known to puppet:/).to_stdout
   end
 
-  it "should declare a preinit block" do
-    expect(@describe).to respond_to(:preinit)
+  it "describes a single type" do
+    describe.command_line.args << 'exec'
+
+    expect {
+      describe.run
+    }.to output(/exec.*====.*Executes external commands/m).to_stdout
   end
 
-  [:providers,:list,:meta].each do |option|
-    it "should declare handle_#{option} method" do
-      expect(@describe).to respond_to("handle_#{option}".to_sym)
-    end
+  it "describes multiple types" do
+    describe.command_line.args.concat(['exec', 'file'])
 
-    it "should store argument value when calling handle_#{option}" do
-      expect(@describe.options).to receive(:[]=).with("#{option}".to_sym, 'arg')
-      @describe.send("handle_#{option}".to_sym, 'arg')
-    end
+    expect {
+      describe.run
+    }.to output(/Executes external commands.*Manages files, including their content, ownership, and permissions./m).to_stdout
   end
 
+  it "describes parameters for the type by default" do
+    describe.command_line.args << 'exec'
 
-  describe "in preinit" do
-    it "should set options[:parameters] to true" do
-      @describe.preinit
+    expect {
+      describe.run
+    }.to output(/Parameters\n----------/m).to_stdout
+  end
 
-      expect(@describe.options[:parameters]).to be_truthy
-    end
+  it "lists parameter names, but excludes description in short mode" do
+    describe.command_line.args.concat(['exec', '-s'])
+
+    expect {
+      describe.run
+    }.to output(/Parameters.*command, creates, cwd/m).to_stdout
   end
 
-  describe "when handling parameters" do
-    it "should set options[:parameters] to false" do
-      @describe.handle_short(nil)
+  it "outputs providers for the type" do
+    describe.command_line.args.concat(['exec', '--providers'])
 
-      expect(@describe.options[:parameters]).to be_falsey
-    end
+    expect {
+      describe.run
+    }.to output(/Providers.*#{Regexp.escape('**posix**')}.*#{Regexp.escape('**windows**')}/m).to_stdout
   end
 
-  describe "during setup" do
-    it "should collect arguments in options[:types]" do
-      allow(@describe.command_line).to receive(:args).and_return(['1','2'])
-      @describe.setup
+  it "lists metaparameters for a type" do
+    describe.command_line.args.concat(['exec', '--meta'])
 
-      expect(@describe.options[:types]).to eq(['1','2'])
-    end
+    expect {
+      describe.run
+    }.to output(/Meta Parameters.*#{Regexp.escape('**notify**')}/m).to_stdout
   end
 
-  describe "when running" do
+  it "outputs no documentation if the summary is missing" do
+    Puppet::Type.newtype(:describe_test) {}
+
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/#{Regexp.escape("describe_test   - .. no documentation ..")}/).to_stdout
+  end
 
-    before :each do
-      @typedoc = double('type_doc')
-      allow(TypeDoc).to receive(:new).and_return(@typedoc)
+  it "outputs the first short sentence ending in a dot" do
+    Puppet::Type.newtype(:describe_test) do
+      @doc = "ends in a dot."
     end
 
-    it "should call list_types if options list is set" do
-      @describe.options[:list] = true
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/#{Regexp.escape("describe_test   - ends in a dot\n")}/).to_stdout
+  end
 
-      expect(@typedoc).to receive(:list_types)
+  it "outputs the first short sentence missing a dot" do
+    Puppet::Type.newtype(:describe_test) do
+      @doc = "missing a dot"
+    end
 
-      @describe.run_command
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/describe_test   - missing a dot\n/).to_stdout
+  end
+
+  it "truncates long summaries ending in a dot" do
+    Puppet::Type.newtype(:describe_test) do
+      @doc = "This sentence is more than 45 characters and ends in a dot."
     end
 
-    it "should call format_type for each given types" do
-      @describe.options[:list] = false
-      @describe.options[:types] = ['type']
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/#{Regexp.escape("describe_test   - This sentence is more than 45 characters and  ...")}/).to_stdout
+  end
 
-      expect(@typedoc).to receive(:format_type).with('type', @describe.options)
-      @describe.run_command
+  it "truncates long summaries missing a dot" do
+    Puppet::Type.newtype(:describe_test) do
+      @doc = "This sentence is more than 45 characters and is missing a dot"
     end
+
+    describe.command_line.args << '--list'
+    expect {
+      describe.run
+    }.to output(/#{Regexp.escape("describe_test   - This sentence is more than 45 characters and  ...")}/).to_stdout
   end
 
-  it "should format text with long non-space runs without garbling" do
-    @f = Formatter.new(76)
+  it "formats text with long non-space runs without garbling" do
+    f = Formatter.new(76)
 
-    @teststring = <<TESTSTRING
+    teststring = <<TESTSTRING
 . 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 nick@magpie.puppetlabs.lan
 **this part should not repeat!**
 TESTSTRING
 
-    @expected_result = <<EXPECTED
+    expected_result = <<EXPECTED
 .
 1234567890123456789012345678901234567890123456789012345678901234567890123456
 7890123456789012345678901234567890 nick@magpie.puppetlabs.lan
 **this part should not repeat!**
 EXPECTED
 
-    result = @f.wrap(@teststring, {:indent => 0, :scrub => true})
-    expect(result).to eql(@expected_result)
+    result = f.wrap(teststring, {:indent => 0, :scrub => true})
+    expect(result).to eql(expected_result)
   end
 end

data/spec/unit/application/device_spec.rb

@@ -459,7 +459,7 @@ describe Puppet::Application::Device do
           resource = Puppet::Type.type(:user).new(:name => "jim").to_resource
           allow(device.command_line).to receive(:args).and_return(['user', 'jim'])
           expect(Puppet::Resource.indirection).to receive(:find).with('user/jim').and_return(resource)
-          expect(device).to receive(:puts).with("user { 'jim':\n}")
+          expect(device).to receive(:puts).with("user { 'jim':\n  ensure => 'absent',\n}")
           expect { device.main }.to exit_with 0
         end
 
@@ -470,7 +470,7 @@ describe Puppet::Application::Device do
           allow(device.options).to receive(:[]).with(:to_yaml).and_return(true)
           allow(device.command_line).to receive(:args).and_return(['user'])
           expect(Puppet::Resource.indirection).to receive(:search).with('user/', {}).and_return(resources)
-          expect(device).to receive(:puts).with("---\nuser:\n  title: {}\n")
+          expect(device).to receive(:puts).with("---\nuser:\n  title:\n    ensure: absent\n")
           expect { device.main }.to exit_with 0
         end
       end

data/spec/unit/application/filebucket_spec.rb

@@ -114,12 +114,31 @@ describe Puppet::Application::Filebucket do
         @filebucket.setup
       end
 
-      it "should default to the first server_list entry if set" do
+      it "should default to the first good server_list entry if server_list is set" do
+        stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 200)
         Puppet[:server_list] = "foo,bar,baz"
         expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "foo"))
         @filebucket.setup
       end
 
+      it "should walk server_list until it finds a good entry" do
+        stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 502)
+        stub_request(:get, "https://bar:8140/status/v1/simple/master").to_return(status: 200)
+        Puppet[:server_list] = "foo,bar,baz"
+        expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "bar"))
+        @filebucket.setup
+      end
+
+      # FileBucket catches any exceptions raised, logs them, then just exits
+      it "raises an error if there are no functional servers in server_list" do
+        stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 404)
+        stub_request(:get, "https://bar:8140/status/v1/simple/master").to_return(status: 404)
+        Puppet[:server] = 'horacio'
+        Puppet[:server_list] = "foo,bar"
+
+        expect{@filebucket.setup}.to exit_with(1)
+      end
+
       it "should fall back to server if server_list is empty" do
         Puppet[:server_list] = ""
         expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "puppet"))
@@ -127,8 +146,9 @@ describe Puppet::Application::Filebucket do
       end
 
       it "should take both the server and port specified in server_list" do
+        stub_request(:get, "https://foo:632/status/v1/simple/master").to_return(status: 200)
         Puppet[:server_list] = "foo:632,bar:6215,baz:351"
-        expect(Puppet::FileBucket::Dipper).to receive(:new).with({ :Server => "foo", :Port => "632" })
+        expect(Puppet::FileBucket::Dipper).to receive(:new).with({ :Server => "foo", :Port => 632 })
         @filebucket.setup
       end
     end

data/spec/unit/application/resource_spec.rb

@@ -12,9 +12,9 @@ describe Puppet::Application::Resource do
   end
 
   describe "in preinit" do
-    it "should init extra_params to empty array" do
+    it "should include provider parameter by default" do
       @resource_app.preinit
-      expect(@resource_app.extra_params).to eq([])
+      expect(@resource_app.extra_params).to eq([:provider])
     end
   end
 

data/spec/unit/concurrent/lock_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'puppet/concurrent/lock'
+
+describe Puppet::Concurrent::Lock do
+  if Puppet::Util::Platform.jruby?
+    context 'on jruby' do
+      it 'synchronizes a block on itself' do
+        iterations = 100
+        value = 0
+
+        lock = Puppet::Concurrent::Lock.new
+        threads = iterations.times.collect do
+          Thread.new do
+            lock.synchronize do
+              tmp = (value += 1)
+              sleep(0.001)
+              # This update using tmp is designed to lose increments if threads overlap
+              value = tmp + 1
+            end
+          end
+        end
+        threads.each(&:join)
+
+        # In my testing this always fails by quite a lot when not synchronized (ie on mri)
+        expect(value).to eq(iterations * 2)
+      end
+    end
+  end
+end

data/spec/unit/configurer/fact_handler_spec.rb

@@ -22,10 +22,6 @@ describe Puppet::Configurer::FactHandler do
 
   let(:facthandler) { FactHandlerTester.new('production') }
 
-  before :each do
-    Puppet::Node::Facts.indirection.terminus_class = :memory
-  end
-
   describe "when finding facts" do
     it "should use the node name value to retrieve the facts" do
       foo_facts = Puppet::Node::Facts.new('foo')

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -6,13 +6,17 @@ describe Puppet::Configurer::PluginHandler do
   let(:pluginhandler) { Puppet::Configurer::PluginHandler.new() }
   let(:environment)   { Puppet::Node::Environment.create(:myenv, []) }
 
+  before :each do
+    # PluginHandler#load_plugin has an extra-strong rescue clause
+    # this mock is to make sure that we don't silently ignore errors
+    expect(Puppet).not_to receive(:err)
+  end
+
   context "server agent version is 5.3.4" do
-    before :each do
-      # PluginHandler#load_plugin has an extra-strong rescue clause
-      # this mock is to make sure that we don't silently ignore errors
-      expect(Puppet).not_to receive(:err)
-      # Server_agent version needs to be at 5.3.4 in order to mount locales
-      Puppet.push_context({:server_agent_version => "5.3.4"})
+    around do |example|
+      Puppet.override(server_agent_version: "5.3.4") do
+        example.run
+      end
     end
 
     it "downloads plugins, facts, and locales" do
@@ -43,12 +47,10 @@ describe Puppet::Configurer::PluginHandler do
   end
 
   context "server agent version is 5.3.3" do
-    before :each do
-      # PluginHandler#load_plugin has an extra-strong rescue clause
-      # this mock is to make sure that we don't silently ignore errors
-      expect(Puppet).not_to receive(:err)
-      # Server_agent version needs to be at 5.3.4 in order to mount locales
-      Puppet.push_context({:server_agent_version => "5.3.3"})
+    around do |example|
+      Puppet.override(server_agent_version: "5.3.3") do
+        example.run
+      end
     end
 
     it "returns downloaded plugin, fact, but not locale filenames" do
@@ -69,15 +71,30 @@ describe Puppet::Configurer::PluginHandler do
   end
 
   context "blank server agent version" do
-    before :each do
-      # PluginHandler#load_plugin has an extra-strong rescue clause
-      # this mock is to make sure that we don't silently ignore errors
-      expect(Puppet).not_to receive(:err)
-      # Server_agent version needs to be at 5.3.4 in order to mount locales
-      # A blank version will default to 0.0
-      Puppet.push_context({:server_agent_version => ""})
+    around do |example|
+      Puppet.override(server_agent_version: "") do
+        example.run
+      end
+    end
+
+    it "returns downloaded plugin, fact, but not locale filenames" do
+      times_called = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        times_called += 1
+
+        if times_called == 1
+          %w[/a]
+        else
+          %w[/b]
+        end
+      end
+
+      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
+      expect(times_called).to eq(2)
     end
+  end
 
+  context "nil server agent version" do
     it "returns downloaded plugin, fact, but not locale filenames" do
       times_called = 0
       allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do

data/spec/unit/configurer_spec.rb

@@ -1,108 +1,88 @@
 require 'spec_helper'
 require 'puppet/configurer'
+require 'webmock/rspec'
 
 describe Puppet::Configurer do
   before do
-    allow(Puppet.settings).to receive(:use).and_return(true)
-    @agent = Puppet::Configurer.new
-    allow(@agent).to receive(:init_storage)
-    allow(Puppet::Util::Storage).to receive(:store)
     Puppet[:server] = "puppetmaster"
     Puppet[:report] = true
-  end
 
-  it "should include the Fact Handler module" do
-    expect(Puppet::Configurer.ancestors).to be_include(Puppet::Configurer::FactHandler)
+    catalog.add_resource(resource)
   end
 
+  let(:node_name) { Puppet[:node_name_value] }
+  let(:configurer) { Puppet::Configurer.new }
+  let(:report) { Puppet::Transaction::Report.new }
+  let(:catalog) { Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
+  let(:resource) { Puppet::Resource.new(:notice, 'a') }
+  let(:facts) { Puppet::Node::Facts.new(node_name) }
+
   describe "when executing a pre-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:prerun_command] = ""
-      expect(Puppet::Util).not_to receive(:exec)
+      expect(Puppet::Util::Execution).not_to receive(:execute)
 
-      @agent.execute_prerun_command
+      configurer.execute_prerun_command
     end
 
     it "should execute any pre-run command provided via the 'prerun_command' setting" do
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      @agent.execute_prerun_command
+      configurer.execute_prerun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      expect(@agent.execute_prerun_command).to be_falsey
+      expect(configurer.execute_prerun_command).to be_falsey
     end
   end
 
   describe "when executing a post-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:postrun_command] = ""
-      expect(Puppet::Util).not_to receive(:exec)
+      expect(Puppet::Util::Execution).not_to receive(:execute)
 
-      @agent.execute_postrun_command
+      configurer.execute_postrun_command
     end
 
     it "should execute any post-run command provided via the 'postrun_command' setting" do
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      @agent.execute_postrun_command
+      configurer.execute_postrun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      expect(@agent.execute_postrun_command).to be_falsey
+      expect(configurer.execute_postrun_command).to be_falsey
     end
   end
 
   describe "when executing a catalog run" do
     before do
-      allow(Puppet.settings).to receive(:use).and_return(true)
-      allow(@agent).to receive(:download_plugins)
-      Puppet::Node::Facts.indirection.terminus_class = :memory
-      @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
-      Puppet::Node::Facts.indirection.save(@facts)
-
-      @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
-      allow(@catalog).to receive(:to_ral).and_return(@catalog)
       Puppet::Resource::Catalog.indirection.terminus_class = :rest
-      allow(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
-      allow(@agent).to receive(:send_report)
-      allow(@agent).to receive(:save_last_run_summary)
-
-      allow(Puppet::Util::Log).to receive(:close_all)
-    end
-
-    after :all do
-      Puppet::Node::Facts.indirection.reset_terminus_class
-      Puppet::Resource::Catalog.indirection.reset_terminus_class
-    end
-
-    it "should initialize storage" do
-      expect(Puppet::Util::Storage).to receive(:load)
-      @agent.run
+      allow(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(catalog)
     end
 
     it "downloads plugins when told" do
-      expect(@agent).to receive(:download_plugins)
-      @agent.run(:pluginsync => true)
+      expect(configurer).to receive(:download_plugins)
+      configurer.run(:pluginsync => true)
     end
 
     it "does not download plugins when told" do
-      expect(@agent).not_to receive(:download_plugins)
-      @agent.run(:pluginsync => false)
+      expect(configurer).not_to receive(:download_plugins)
+      configurer.run(:pluginsync => false)
     end
 
     it "should carry on when it can't fetch its node definition" do
       error = Net::HTTPError.new(400, 'dummy server communication error')
       expect(Puppet::Node.indirection).to receive(:find).and_raise(error)
-      expect(@agent.run).to eq(0)
+      expect(configurer.run).to eq(0)
     end
 
     it "applies a cached catalog when it can't connect to the master" do
@@ -110,200 +90,158 @@ describe Puppet::Configurer do
 
       expect(Puppet::Node.indirection).to receive(:find).and_raise(error)
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(:ignore_cache => true)).and_raise(error)
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(:ignore_terminus => true)).and_return(@catalog)
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(:ignore_terminus => true)).and_return(catalog)
 
-      expect(@agent.run).to eq(0)
+      expect(configurer.run).to eq(0)
     end
 
     it "should initialize a transaction report if one is not provided" do
-      report = Puppet::Transaction::Report.new
       expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
-      @agent.run
+      configurer.run
     end
 
     it "should respect node_name_fact when setting the host on a report" do
+      Puppet[:node_name_value] = nil
       Puppet[:node_name_fact] = 'my_name_fact'
-      @facts.values = {'my_name_fact' => 'node_name_from_fact'}
+      facts.values = {'my_name_fact' => 'node_name_from_fact'}
+      Puppet::Node::Facts.indirection.save(facts)
 
-      report = Puppet::Transaction::Report.new
-
-      @agent.run(:report => report)
+      configurer.run(:report => report)
       expect(report.host).to eq('node_name_from_fact')
     end
 
-    it "should pass the new report to the catalog" do
-      report = Puppet::Transaction::Report.new
-      allow(Puppet::Transaction::Report).to receive(:new).and_return(report)
-      expect(@catalog).to receive(:apply).with(hash_including(report: report))
-
-      @agent.run
-    end
-
-    it "should use the provided report if it was passed one" do
-      report = Puppet::Transaction::Report.new
-      expect(@catalog).to receive(:apply).with(hash_including(report: report))
-
-      @agent.run(:report => report)
-    end
-
-    it "should set the report as a log destination" do
-      report = Puppet::Transaction::Report.new
-
-      expect(report).to receive(:<<).with(instance_of(Puppet::Util::Log)).at_least(:once)
+    it "creates a new report when applying the catalog" do
+      options = {}
+      configurer.run(options)
 
-      @agent.run(:report => report)
+      expect(options[:report].metrics['time']['catalog_application']).to be_an_instance_of(Float)
     end
 
-    it "should retrieve the catalog" do
-      expect(@agent).to receive(:retrieve_catalog)
+    it "uses the provided report when applying the catalog" do
+      configurer.run(:report => report)
 
-      @agent.run
+      expect(report.metrics['time']['catalog_application']).to be_an_instance_of(Float)
     end
 
     it "should log a failure and do nothing if no catalog can be retrieved" do
-      expect(@agent).to receive(:retrieve_catalog).and_return(nil)
+      expect(configurer).to receive(:retrieve_catalog).and_return(nil)
 
       expect(Puppet).to receive(:err).with("Could not retrieve catalog; skipping run")
 
-      @agent.run
+      configurer.run
     end
 
-    it "should apply the catalog with all options to :run" do
-      expect(@agent).to receive(:retrieve_catalog).and_return(@catalog)
+    it "passes arbitrary options when applying the catalog" do
+      expect(catalog).to receive(:apply).with(hash_including(one: true))
 
-      expect(@catalog).to receive(:apply).with(hash_including(one: true))
-      @agent.run :one => true
-    end
-
-    it "should accept a catalog and use it instead of retrieving a different one" do
-      expect(@agent).not_to receive(:retrieve_catalog)
-
-      expect(@catalog).to receive(:apply)
-      @agent.run :one => true, :catalog => @catalog
+      configurer.run(catalog: catalog, one: true)
     end
 
     it "should benchmark how long it takes to apply the catalog" do
-      expect(@agent).to receive(:benchmark).with(:notice, instance_of(String))
-
-      expect(@agent).to receive(:retrieve_catalog).and_return(@catalog)
-
-      expect(@catalog).not_to receive(:apply) # because we're not yielding
-      @agent.run
-    end
-
-    it "should execute post-run hooks after the run" do
-      expect(@agent).to receive(:execute_postrun_command)
+      configurer.run(report: report)
 
-      @agent.run
+      expect(report.logs).to include(an_object_having_attributes(level: :notice, message: /Applied catalog in .* seconds/))
     end
 
     it "should create report with passed transaction_uuid and job_id" do
-      @agent = Puppet::Configurer.new("test_tuuid", "test_jid")
-      allow(@agent).to receive(:init_storage)
+      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(@agent).to receive(:send_report).with(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)
 
-      @agent.run
+      configurer.run
     end
 
     it "should send the report" do
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-      expect(@agent).to receive(:send_report).with(report)
+      expect(configurer).to receive(:send_report).with(report)
 
       expect(report.environment).to eq("test")
       expect(report.transaction_uuid).to eq("aaaa")
 
-      @agent.run
+      configurer.run
     end
 
     it "should send the transaction report even if the catalog could not be retrieved" do
-      expect(@agent).to receive(:retrieve_catalog).and_return(nil)
+      expect(configurer).to receive(:retrieve_catalog).and_return(nil)
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-      expect(@agent).to receive(:send_report).with(report)
+      expect(configurer).to receive(:send_report).with(report)
 
       expect(report.environment).to eq("test")
       expect(report.transaction_uuid).to eq("aaaa")
 
-      @agent.run
+      configurer.run
     end
 
     it "should send the transaction report even if there is a failure" do
-      expect(@agent).to receive(:retrieve_catalog).and_raise("whatever")
+      expect(configurer).to receive(:retrieve_catalog).and_raise("whatever")
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-      expect(@agent).to receive(:send_report).with(report)
+      expect(configurer).to receive(:send_report).with(report)
 
       expect(report.environment).to eq("test")
       expect(report.transaction_uuid).to eq("aaaa")
 
-      expect(@agent.run).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should remove the report as a log destination when the run is finished" do
-      report = Puppet::Transaction::Report.new
       expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
-      @agent.run
+      configurer.run
 
       expect(Puppet::Util::Log.destinations).not_to include(report)
     end
 
     it "should return the report exit_status as the result of the run" do
-      report = Puppet::Transaction::Report.new
       expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
       expect(report).to receive(:exit_status).and_return(1234)
 
-      expect(@agent.run).to eq(1234)
+      expect(configurer.run).to eq(1234)
     end
 
     it "should return nil if catalog application fails" do
-      expect(@catalog).to receive(:apply).and_raise(Puppet::Error, 'One or more resource dependency cycles detected in graph')
-      report = Puppet::Transaction::Report.new
-      expect(@agent.run(catalog: @catalog, report: report)).to be_nil
+      expect_any_instance_of(Puppet::Resource::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
 
     it "should send the transaction report even if the pre-run command fails" do
-      report = Puppet::Transaction::Report.new
       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(@agent).to receive(:send_report).with(report)
+      expect(configurer).to receive(:send_report).with(report)
 
-      expect(@agent.run).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should include the pre-run command failure in the report" do
-      report = Puppet::Transaction::Report.new
       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(@agent.run).to be_nil
+      expect(configurer.run).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
-      report = Puppet::Transaction::Report.new
       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(@agent).to receive(:send_report).with(report)
+      expect(configurer).to receive(:send_report).with(report)
 
-      expect(@agent.run).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should include the post-run command failure in the report" do
-      report = Puppet::Transaction::Report.new
       expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
@@ -311,7 +249,7 @@ describe Puppet::Configurer do
 
       expect(report).to receive(:<<) { |log, _| expect(log.message).to match(/Could not run command from postrun_command/) }.at_least(:once)
 
-      expect(@agent.run).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should execute post-run command even if the pre-run command fails" do
@@ -320,47 +258,42 @@ describe Puppet::Configurer do
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/precommand"]).and_raise(Puppet::ExecutionFailure, "Failed")
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/postcommand"])
 
-      expect(@agent.run).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should finalize the report" do
-      report = Puppet::Transaction::Report.new
       expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       expect(report).to receive(:finalize_report)
-      @agent.run
+      configurer.run
     end
 
     it "should not apply the catalog if the pre-run command fails" do
-      report = Puppet::Transaction::Report.new
       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(@catalog).not_to receive(:apply)
-      expect(@agent).to receive(:send_report)
+      expect_any_instance_of(Puppet::Resource::Catalog).not_to receive(:apply)
+      expect(configurer).to receive(:send_report)
 
-      expect(@agent.run).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should apply the catalog, send the report, and return nil if the post-run command fails" do
-      report = Puppet::Transaction::Report.new
       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(@catalog).to receive(:apply)
-      expect(@agent).to receive(:send_report)
+      expect_any_instance_of(Puppet::Resource::Catalog).to receive(:apply)
+      expect(configurer).to receive(:send_report)
 
-      expect(@agent.run).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it 'includes total time metrics in the report after successfully applying the catalog' do
-      report = Puppet::Transaction::Report.new
-      allow(@catalog).to receive(:apply).with(hash_including(report: report))
-      @agent.run(report: report)
+      configurer.run(report: report)
 
       expect(report.metrics['time']).to be
       expect(report.metrics['time']['total']).to be_a_kind_of(Numeric)
@@ -370,120 +303,109 @@ describe Puppet::Configurer do
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      report = Puppet::Transaction::Report.new
-      @agent.run(report: report)
+      configurer.run(report: report)
 
       expect(report.metrics['time']).to be
       expect(report.metrics['time']['total']).to be_a_kind_of(Numeric)
     end
 
     it 'includes total time metrics in the report even if catalog retrieval fails' do
-      report = Puppet::Transaction::Report.new
-      allow(@agent).to receive(:prepare_and_retrieve_catalog_from_cache).and_raise
-      @agent.run(:report => report)
+      allow(configurer).to receive(:prepare_and_retrieve_catalog_from_cache).and_raise
+      configurer.run(:report => report)
 
       expect(report.metrics['time']).to be
       expect(report.metrics['time']['total']).to be_a_kind_of(Numeric)
     end
 
     it "should refetch the catalog if the server specifies a new environment in the catalog" do
-      catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
-      expect(@agent).to receive(:retrieve_catalog).and_return(catalog).twice
+      catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote('second_env'))
+      expect(configurer).to receive(:retrieve_catalog).and_return(catalog).twice
 
-      @agent.run
+      configurer.run
     end
 
-    it "should change the environment setting if the server specifies a new environment in the catalog" do
-      allow(@catalog).to receive(:environment).and_return("second_env")
+    it "changes the configurer's environment if the server specifies a new environment in the catalog" do
+      allow_any_instance_of(Puppet::Resource::Catalog).to receive(:environment).and_return("second_env")
 
-      @agent.run
+      configurer.run
 
-      expect(@agent.environment).to eq("second_env")
+      expect(configurer.environment).to eq("second_env")
     end
 
-    it "should fix the report if the server specifies a new environment in the catalog" do
-      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-      expect(@agent).to receive(:send_report).with(report)
-
-      allow(@catalog).to receive(:environment).and_return("second_env")
-      allow(@agent).to receive(:retrieve_catalog).and_return(@catalog)
+    it "changes the report's environment if the server specifies a new environment in the catalog" do
+      allow_any_instance_of(Puppet::Resource::Catalog).to receive(:environment).and_return("second_env")
 
-      @agent.run
+      configurer.run(report: report)
 
       expect(report.environment).to eq("second_env")
     end
 
     it "sends the transaction uuid in a catalog request" do
-      @agent.instance_variable_set(:@transaction_uuid, 'aaa')
+      configurer = Puppet::Configurer.new('aaa')
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(transaction_uuid: 'aaa'))
-      @agent.run
+      configurer.run
     end
 
     it "sends the transaction uuid in a catalog request" do
-      @agent.instance_variable_set(:@job_id, 'aaa')
+      configurer = Puppet::Configurer.new('b', 'aaa')
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(job_id: 'aaa'))
-      @agent.run
+      configurer.run
     end
 
     it "sets the static_catalog query param to true in a catalog request" do
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(static_catalog: true))
-      @agent.run
+      configurer.run
     end
 
     it "sets the checksum_type query param to the default supported_checksum_types in a catalog request" do
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything,
         hash_including(checksum_type: 'md5.sha256.sha384.sha512.sha224'))
-      @agent.run
+      configurer.run
     end
 
     it "sets the checksum_type query param to the supported_checksum_types setting in a catalog request" do
-      # Regenerate the agent to pick up the new setting
       Puppet[:supported_checksum_types] = ['sha256']
-      @agent = Puppet::Configurer.new
-      allow(@agent).to receive(:init_storage)
-      allow(@agent).to receive(:download_plugins)
-      allow(@agent).to receive(:send_report)
-      allow(@agent).to receive(:save_last_run_summary)
+      # Regenerate the agent to pick up the new setting
+      configurer = Puppet::Configurer.new
 
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(checksum_type: 'sha256'))
-      @agent.run
+      configurer.run
     end
 
     describe "when not using a REST terminus for catalogs" do
       it "should not pass any facts when retrieving the catalog" do
+        # This is weird, we collect facts when constructing the node,
+        # but we don't send them in the indirector request. Then the compiler
+        # looks up the node, and collects its facts, which we could have sent
+        # in the first place. This seems like a bug.
         Puppet::Resource::Catalog.indirection.terminus_class = :compiler
-        expect(@agent).not_to receive(:facts_for_uploading)
+
         expect(Puppet::Resource::Catalog.indirection).to receive(:find) do |name, options|
-          options[:facts].nil?
-        end.and_return(@catalog)
+          expect(options[:facts]).to be_nil
+        end.and_return(catalog)
 
-        @agent.run
+        configurer.run
       end
     end
 
     describe "when using a REST terminus for catalogs" do
-      it "should pass the prepared facts and the facts format as arguments when retrieving the catalog" do
+      it "should pass the url encoded facts and facts format as arguments when retrieving the catalog" do
         Puppet::Resource::Catalog.indirection.terminus_class = :rest
-        # the "facts_for_uploading" are prepeared by first finding facts, and then encoding them
-        # this mocks the "find" with a special value 12345, which is then expected back in the
-        # call to "encode" - the encode in turn returns mocked data that is asserted as being
-        # presented to the catalog terminus as options.
-        #
-        expect(@agent).to receive(:find_facts).and_return(12345)
-        expect(@agent).to receive(:encode_facts).with(12345).and_return(:facts => "myfacts", :facts_format => :foo)
-        expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(facts: "myfacts", facts_format: :foo)).and_return(@catalog)
-
-        @agent.run
-      end
-    end
-  end
 
-  describe "when initialized with a transaction_uuid" do
-    it "stores it" do
-      expect(SecureRandom).not_to receive(:uuid)
-      configurer = Puppet::Configurer.new('foo')
-      expect(configurer.instance_variable_get(:@transaction_uuid) == 'foo')
+        facts.values = { 'foo' => 'bar' }
+        Puppet::Node::Facts.indirection.save(facts)
+
+        expect(
+          Puppet::Resource::Catalog.indirection
+        ).to receive(:find) do |_, options|
+          expect(options[:facts_format]).to eq("application/json")
+
+          unescaped = JSON.parse(CGI.unescape(options[:facts]))
+          expect(unescaped).to include("values" => {"foo" => "bar"})
+        end.and_return(catalog)
+
+        configurer.run
+      end
     end
   end
 
@@ -491,56 +413,52 @@ describe Puppet::Configurer do
     include PuppetSpec::Files
 
     before do
-      allow(Puppet.settings).to receive(:use).and_return(true)
-      @configurer = Puppet::Configurer.new
       Puppet[:lastrunfile] = tmpfile('last_run_file')
-
-      @report = Puppet::Transaction::Report.new
       Puppet[:reports] = "none"
     end
 
     it "should print a report summary if configured to do so" do
       Puppet.settings[:summarize] = true
 
-      expect(@report).to receive(:summary).and_return("stuff")
+      expect(report).to receive(:summary).and_return("stuff")
 
-      expect(@configurer).to receive(:puts).with("stuff")
-      @configurer.send_report(@report)
+      expect(configurer).to receive(:puts).with("stuff")
+      configurer.send_report(report)
     end
 
     it "should not print a report summary if not configured to do so" do
       Puppet.settings[:summarize] = false
 
-      expect(@configurer).not_to receive(:puts)
-      @configurer.send_report(@report)
+      expect(configurer).not_to receive(:puts)
+      configurer.send_report(report)
     end
 
     it "should save the report if reporting is enabled" do
       Puppet.settings[:report] = true
 
-      expect(Puppet::Transaction::Report.indirection).to receive(:save).with(@report, nil, instance_of(Hash))
-      @configurer.send_report(@report)
+      expect(Puppet::Transaction::Report.indirection).to receive(:save).with(report, nil, instance_of(Hash))
+      configurer.send_report(report)
     end
 
     it "should not save the report if reporting is disabled" do
       Puppet.settings[:report] = false
 
-      expect(Puppet::Transaction::Report.indirection).not_to receive(:save).with(@report, nil, instance_of(Hash))
-      @configurer.send_report(@report)
+      expect(Puppet::Transaction::Report.indirection).not_to receive(:save).with(report, nil, instance_of(Hash))
+      configurer.send_report(report)
     end
 
     it "should save the last run summary if reporting is enabled" do
       Puppet.settings[:report] = true
 
-      expect(@configurer).to receive(:save_last_run_summary).with(@report)
-      @configurer.send_report(@report)
+      expect(configurer).to receive(:save_last_run_summary).with(report)
+      configurer.send_report(report)
     end
 
     it "should save the last run summary if reporting is disabled" do
       Puppet.settings[:report] = false
 
-      expect(@configurer).to receive(:save_last_run_summary).with(@report)
-      @configurer.send_report(@report)
+      expect(configurer).to receive(:save_last_run_summary).with(report)
+      configurer.send_report(report)
     end
 
     it "should log but not fail if saving the report fails" do
@@ -548,8 +466,9 @@ describe Puppet::Configurer do
 
       expect(Puppet::Transaction::Report.indirection).to receive(:save).and_raise("whatever")
 
-      expect(Puppet).to receive(:send_log).with(:err, 'Could not send report: whatever')
-      @configurer.send_report(@report)
+      configurer.send_report(report)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: 'Could not send report: whatever'))
     end
   end
 
@@ -557,22 +476,17 @@ describe Puppet::Configurer do
     include PuppetSpec::Files
 
     before do
-      allow(Puppet.settings).to receive(:use).and_return(true)
-      @configurer = Puppet::Configurer.new
-
-      @report = double('report', :raw_summary => {})
-
       Puppet[:lastrunfile] = tmpfile('last_run_file')
     end
 
     it "should write the last run file" do
-      @configurer.save_last_run_summary(@report)
+      configurer.save_last_run_summary(report)
       expect(Puppet::FileSystem.exist?(Puppet[:lastrunfile])).to be_truthy
     end
 
     it "should write the raw summary as yaml" do
-      expect(@report).to receive(:raw_summary).and_return("summary")
-      @configurer.save_last_run_summary(@report)
+      expect(report).to receive(:raw_summary).and_return("summary")
+      configurer.save_last_run_summary(report)
       expect(File.read(Puppet[:lastrunfile])).to eq(YAML.dump("summary"))
     end
 
@@ -587,13 +501,14 @@ describe Puppet::Configurer do
 
       expect(Puppet::Util).to receive(:replace_file).and_yield(fh)
 
-      expect(Puppet).to receive(:send_log).with(:err, 'Could not save last run local report: failed to do print')
-      @configurer.save_last_run_summary(@report)
+      configurer.save_last_run_summary(report)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: 'Could not save last run local report: failed to do print'))
     end
 
     it "should create the last run file with the correct mode" do
       expect(Puppet.settings.setting(:lastrunfile)).to receive(:mode).and_return('664')
-      @configurer.save_last_run_summary(@report)
+      configurer.save_last_run_summary(report)
 
       if Puppet::Util::Platform.windows?
         require 'puppet/util/windows/security'
@@ -606,26 +521,28 @@ describe Puppet::Configurer do
 
     it "should report invalid last run file permissions" do
       expect(Puppet.settings.setting(:lastrunfile)).to receive(:mode).and_return('892')
-      expect(Puppet).to receive(:send_log).with(:err, /Could not save last run local report.*892 is invalid/)
-      @configurer.save_last_run_summary(@report)
+
+      configurer.save_last_run_summary(report)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: /Could not save last run local report.*892 is invalid/))
     end
   end
 
   describe "when requesting a node" do
     it "uses the transaction uuid in the request" do
       expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(transaction_uuid: anything)).twice
-      @agent.run
+      configurer.run
     end
 
     it "sends an explicitly configured environment request" do
       expect(Puppet.settings).to receive(:set_by_config?).with(:environment).and_return(true)
       expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(configured_environment: Puppet[:environment])).twice
-      @agent.run
+      configurer.run
     end
 
     it "does not send a configured_environment when using the default" do
       expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(configured_environment: nil)).twice
-      @agent.run
+      configurer.run
     end
   end
 
@@ -656,14 +573,6 @@ describe Puppet::Configurer do
 
   describe "when retrieving a catalog" do
     before do
-      allow(Puppet.settings).to receive(:use).and_return(true)
-      allow(@agent).to receive(:facts_for_uploading).and_return({})
-      allow(@agent).to receive(:download_plugins)
-
-      # retrieve a catalog in the current environment, so we don't try to converge unexpectedly
-      @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
-
-      # this is the default when using a Configurer instance
       allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:rest)
     end
 
@@ -673,101 +582,139 @@ describe Puppet::Configurer do
       end
 
       it "should first look in the cache for a catalog" do
-        expects_cached_catalog_only(@catalog)
+        expects_cached_catalog_only(catalog)
 
-        expect(@agent.retrieve_catalog({})).to eq(@catalog)
+        configurer.run
       end
 
       it "should not make a node request or pluginsync when a cached catalog is successfully retrieved" do
         expect(Puppet::Node.indirection).not_to receive(:find)
-        expects_cached_catalog_only(@catalog)
-        expect(@agent).not_to receive(:download_plugins)
+        expects_cached_catalog_only(catalog)
+        expect(configurer).not_to receive(:download_plugins)
 
-        @agent.run
+        configurer.run
       end
 
       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(@agent).to receive(:download_plugins)
+        expects_fallback_to_new_catalog(catalog)
+        expect(configurer).to receive(:download_plugins)
 
-        @agent.run
+        configurer.run
       end
 
       it "should set its cached_catalog_status to 'explicitly_requested'" do
-        expects_cached_catalog_only(@catalog)
+        expects_cached_catalog_only(catalog)
+
+        options = {}
+        configurer.run(options)
 
-        @agent.retrieve_catalog({})
-        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('explicitly_requested')
+        expect(options[:report].cached_catalog_status).to eq('explicitly_requested')
       end
 
       it "should set its cached_catalog_status to 'explicitly requested' if the cached catalog is from a different environment" do
-        cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+        cached_catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote('second_env'))
         expects_cached_catalog_only(cached_catalog)
 
-        @agent.retrieve_catalog({})
-        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('explicitly_requested')
-      end
-
-      it "should compile a new catalog if none is found in the cache" do
-        expects_fallback_to_new_catalog(@catalog)
+        options = {}
+        configurer.run(options)
 
-        expect(@agent.retrieve_catalog({})).to eq(@catalog)
+        expect(options[:report].cached_catalog_status).to eq('explicitly_requested')
       end
 
-      it "should set its cached_catalog_status to 'not_used' if no catalog is found in the cache" do
-        expects_fallback_to_new_catalog(@catalog)
+      it "should pluginsync and compile a new catalog if none is found in the cache" do
+        expects_fallback_to_new_catalog(catalog)
+        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)
 
-        @agent.retrieve_catalog({})
-        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+        options = {}
+        configurer.run(options)
+
+        expect(options[:report].cached_catalog_status).to eq('not_used')
       end
 
       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
 
-        @agent.run
+        # after failing to use a cached catalog, we'll need to pluginsync before getting
+        # a new catalog, which also fails.
+        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)
+
+        configurer.run
       end
 
       it "should return the cached catalog when the environment doesn't match" do
-        cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+        cached_catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote('second_env'))
         expects_cached_catalog_only(cached_catalog)
 
+        allow(Puppet).to receive(:info)
         expect(Puppet).to receive(:info).with("Using cached catalog from environment 'second_env'")
-        expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+
+        configurer.run
+      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)
+
+        catalog.add_resource(Puppet::Resource.new('notify', 'from apply'))
+        configurer.run(catalog: catalog.to_ral)
+
+        # make sure cache class is not set to avoid surprises later
+        expect(Puppet::Resource::Catalog.indirection).to_not be_cache
+        expect(@logs).to include(an_object_having_attributes(level: :notice, message: /defined 'message' as 'from apply'/))
+      end
+
+      it "applies the cached catalog when the catalog cache terminus is set, ignoring the catalog passed as options" do
+        Puppet::Resource::Catalog.indirection.cache_class = :json
+
+        cached_catalog = Puppet::Resource::Catalog.new(Puppet[:node_name_value], Puppet[:environment])
+        cached_catalog.add_resource(Puppet::Resource.new('notify', 'from cache'))
+
+        # update cached catalog
+        Puppet.settings.use(:main, :agent)
+        path = Puppet::Resource::Catalog.indirection.cache.path(cached_catalog.name)
+        FileUtils.mkdir(File.dirname(path))
+        File.write(path, cached_catalog.render(:json))
+
+        configurer.run(catalog: catalog.to_ral)
+
+        expect(@logs).to include(an_object_having_attributes(level: :notice, message: /defined 'message' as 'from cache'/))
       end
     end
 
     describe "and strict environment mode is set" do
       before do
-        allow(@catalog).to receive(:to_ral).and_return(@catalog)
-        allow(@catalog).to receive(:write_class_file)
-        allow(@catalog).to receive(:write_resource_file)
-        allow(@agent).to receive(:send_report)
-        allow(@agent).to receive(:save_last_run_summary)
         Puppet.settings[:strict_environment_mode] = true
       end
 
       it "should not make a node request" do
-        expects_new_catalog_only(@catalog)
+        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_new_catalog_only(catalog)
+
         expect(Puppet::Node.indirection).not_to receive(:find)
 
-        @agent.run
+        configurer.run
       end
 
       it "should return nil when the catalog's environment doesn't match the agent specified environment" do
-        @agent.instance_variable_set(:@environment, 'second_env')
-        expects_new_catalog_only(@catalog)
+        Puppet[:environment] = 'second_env'
+        configurer = Puppet::Configurer.new
+
+        catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote("production"))
+        expects_new_catalog_only(catalog)
 
         expect(Puppet).to receive(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
-        expect(@agent.run).to be_nil
+        expect(configurer.run).to be_nil
       end
 
-      it "should not return nil when the catalog's environment matches the agent specified environment" do
-        @agent.instance_variable_set(:@environment, 'production')
-        expects_new_catalog_only(@catalog)
+      it "should return 0 when the catalog's environment matches the agent specified environment" do
+        expects_new_catalog_only(catalog)
 
-        expect(@agent.run).to eq(0)
+        expect(configurer.run).to eq(0)
       end
 
       describe "and a cached catalog is explicitly requested" do
@@ -776,83 +723,81 @@ describe Puppet::Configurer do
         end
 
         it "should return nil when the cached catalog's environment doesn't match the agent specified environment" do
-          @agent.instance_variable_set(:@environment, 'second_env')
-          expects_cached_catalog_only(@catalog)
+          Puppet[:environment] = 'second_env'
+          configurer = Puppet::Configurer.new
+
+          catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote("production"))
+          expects_cached_catalog_only(catalog)
 
           expect(Puppet).to receive(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
-          expect(@agent.run).to be_nil
+          expect(configurer.run).to be_nil
         end
 
         it "should proceed with the cached catalog if its environment matchs the local environment" do
-          Puppet.settings[:use_cached_catalog] = true
-          @agent.instance_variable_set(:@environment, 'production')
-          expects_cached_catalog_only(@catalog)
+          expects_cached_catalog_only(catalog)
 
-          expect(@agent.run).to eq(0)
+          expect(configurer.run).to eq(0)
         end
       end
     end
 
-    it "should use the Catalog class to get its catalog" do
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
-
-      @agent.retrieve_catalog({})
-    end
-
     it "should set its cached_catalog_status to 'not_used' when downloading a new catalog" do
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(@catalog)
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
 
-      @agent.retrieve_catalog({})
-      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+      options = {}
+      configurer.run(options)
+
+      expect(options[:report].cached_catalog_status).to eq('not_used')
     end
 
     it "should use its node_name_value to retrieve the catalog" do
-      allow(Facter).to receive(:value).and_return("eh")
-      Puppet.settings[:node_name_value] = "myhost.domain.com"
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with("myhost.domain.com", anything).and_return(@catalog)
+      myhost_facts = Puppet::Node::Facts.new("myhost.domain.com")
+      Puppet::Node::Facts.indirection.save(myhost_facts)
 
-      @agent.retrieve_catalog({})
-    end
-
-    it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(@catalog)
+      Puppet.settings[:node_name_value] = "myhost.domain.com"
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with("myhost.domain.com", anything).and_return(catalog)
 
-      expect(@agent.retrieve_catalog({})).to eq(@catalog)
+      configurer.run
     end
 
-    it "should log and return the cached catalog when no catalog can be retrieved from the server" do
-      expects_fallback_to_cached_catalog(@catalog)
+    it "should log when no catalog can be retrieved from the server" do
+      expects_fallback_to_cached_catalog(catalog)
 
+      allow(Puppet).to receive(:info)
       expect(Puppet).to receive(:info).with("Using cached catalog from environment 'production'")
-      expect(@agent.retrieve_catalog({})).to eq(@catalog)
+      configurer.run
     end
 
     it "should set its cached_catalog_status to 'on_failure' when no catalog can be retrieved from the server" do
-      expects_fallback_to_cached_catalog(@catalog)
+      expects_fallback_to_cached_catalog(catalog)
 
-      @agent.retrieve_catalog({})
-      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+      options = {}
+      configurer.run(options)
+
+      expect(options[:report].cached_catalog_status).to eq('on_failure')
     end
 
     it "should not look in the cache for a catalog if one is returned from the server" do
-      expects_new_catalog_only(@catalog)
+      expects_new_catalog_only(catalog)
 
-      expect(@agent.retrieve_catalog({})).to eq(@catalog)
+      configurer.run
     end
 
     it "should return the cached catalog when retrieving the remote catalog throws an exception" do
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_raise("eh")
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(@catalog)
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(catalog)
 
-      expect(@agent.retrieve_catalog({})).to eq(@catalog)
+      configurer.run
     end
 
     it "should set its cached_catalog_status to 'on_failure' when retrieving the remote catalog throws an exception" do
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_raise("eh")
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(@catalog)
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(catalog)
+
+      options = {}
+      configurer.run(options)
 
-      @agent.retrieve_catalog({})
-      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+      expect(options[:report].cached_catalog_status).to eq('on_failure')
     end
 
     it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
@@ -861,120 +806,173 @@ describe Puppet::Configurer do
 
       expect(Puppet).to receive(:warning).with('Not using cache on failed catalog')
 
-      expect(@agent.retrieve_catalog({})).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should set its cached_catalog_status to 'not_used' if no catalog can be retrieved from the server and :usecacheonfailure is disabled or fails to retrieve a catalog" do
       Puppet[:usecacheonfailure] = false
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(nil)
 
-      @agent.retrieve_catalog({})
-      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+      options = {}
+      configurer.run(options)
+
+      expect(options[:report].cached_catalog_status).to eq('not_used')
     end
 
     it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
       expects_neither_new_or_cached_catalog
 
-      expect(@agent.retrieve_catalog({})).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should return nil if its cached catalog environment doesn't match server-specified environment" do
-      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
-      @agent.instance_variable_set(:@node_environment, 'production')
+      cached_catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote('second_env'))
 
       expects_fallback_to_cached_catalog(cached_catalog)
 
+      allow(Puppet).to receive(:err)
       expect(Puppet).to receive(:err).with("Not using cached catalog because its environment 'second_env' does not match 'production'")
-      expect(@agent.retrieve_catalog({})).to be_nil
+      expect(configurer.run).to be_nil
     end
 
     it "should set its cached_catalog_status to 'not_used' if the cached catalog environment doesn't match server-specified environment" do
-      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
-      @agent.instance_variable_set(:@node_environment, 'production')
+      cached_catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote('second_env'))
 
       expects_fallback_to_cached_catalog(cached_catalog)
 
-      @agent.retrieve_catalog({})
-      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
-    end
-
-    it "should return its cached catalog if the environment matches the server-specified environment" do
-      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment]))
-      @agent.instance_variable_set(:@node_environment, cached_catalog.environment)
-
-      expects_fallback_to_cached_catalog(cached_catalog)
-
-      expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+      options = {}
+      configurer.run(options)
+      expect(options[:report].cached_catalog_status).to eq('not_used')
     end
 
     it "should set its cached_catalog_status to 'on_failure' if the cached catalog environment matches server-specified environment" do
-      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment]))
-      @agent.instance_variable_set(:@node_environment, cached_catalog.environment)
-
-      expects_fallback_to_cached_catalog(cached_catalog)
+      expects_fallback_to_cached_catalog(catalog)
 
-      @agent.retrieve_catalog({})
-      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+      options = {}
+      configurer.run(options)
+      expect(options[:report].cached_catalog_status).to eq('on_failure')
     end
 
     it "should not update the cached catalog in noop mode" do
       Puppet[:noop] = true
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true, ignore_cache_save: true)).and_return(@catalog)
 
-      @agent.retrieve_catalog({})
+      stub_request(:post, %r{/puppet/v3/catalog}).to_return(:status => 200, :body => catalog.render(:json), :headers => {'Content-Type' => 'application/json'})
+
+      Puppet::Resource::Catalog.indirection.cache_class = :json
+      path = Puppet::Resource::Catalog.indirection.cache.path(catalog.name)
+
+      expect(File).to_not be_exist(path)
+      configurer.run
+      expect(File).to_not be_exist(path)
     end
 
     it "should update the cached catalog when not in noop mode" do
       Puppet[:noop] = false
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true, ignore_cache_save: false)).and_return(@catalog)
+      Puppet[:log_level] = 'info'
+
+      stub_request(:post, %r{/puppet/v3/catalog}).to_return(:status => 200, :body => catalog.render(:json), :headers => {'Content-Type' => 'application/json'})
+
+      Puppet::Resource::Catalog.indirection.cache_class = :json
+      cache_path = Puppet::Resource::Catalog.indirection.cache.path(Puppet[:node_name_value])
+
+      expect(File).to_not be_exist(cache_path)
+      configurer.run
+      expect(File).to be_exist(cache_path)
+
+      expect(@logs).to include(an_object_having_attributes(level: :info, message: "Caching catalog for #{Puppet[:node_name_value]}"))
+    end
+
+    it "successfully applies the catalog without a cache" do
+      stub_request(:post, %r{/puppet/v3/catalog}).to_return(:status => 200, :body => catalog.render(:json), :headers => {'Content-Type' => 'application/json'})
+
+      Puppet::Resource::Catalog.indirection.cache_class = nil
+
+      expect(configurer.run).to eq(0)
+    end
+
+    it "should not update the cached catalog when running puppet apply" do
+      Puppet::Resource::Catalog.indirection.cache_class = :json
+      path = Puppet::Resource::Catalog.indirection.cache.path(catalog.name)
 
-      @agent.retrieve_catalog({})
+      expect(File).to_not be_exist(path)
+      configurer.run(catalog: catalog)
+      expect(File).to_not be_exist(path)
     end
   end
 
-  describe "when converting the catalog" do
-    before do
-      allow(Puppet.settings).to receive(:use).and_return(true)
+  describe "when converging the environment" do
+    let(:apple) { Puppet::Resource::Catalog.new(Puppet[:node_name_value], Puppet::Node::Environment.remote('apple')) }
+    let(:banana) { Puppet::Resource::Catalog.new(Puppet[:node_name_value], Puppet::Node::Environment.remote('banana')) }
 
-      allow(catalog).to receive(:to_ral).and_return(ral_catalog)
+    before :each do
+      apple.add_resource(resource)
+      banana.add_resource(resource)
     end
 
-    let (:catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
-    let (:ral_catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
+    it "converges after multiple attempts" do
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(apple, banana, banana)
+
+      allow(Puppet).to receive(:notice)
+      expect(Puppet).to receive(:notice).with("Local environment: 'production' doesn't match server specified environment 'apple', restarting agent run with environment 'apple'")
+      expect(Puppet).to receive(:notice).with("Local environment: 'apple' doesn't match server specified environment 'banana', restarting agent run with environment 'banana'")
 
-    it "should convert the catalog to a RAL-formed catalog" do
-      expect(@agent.convert_catalog(catalog, 10)).to equal(ral_catalog)
+      configurer.run
     end
 
-    it "should finalize the catalog" do
-      expect(ral_catalog).to receive(:finalize)
+    it "raises if it can't converge after 4 tries after the initial catalog request" do
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(apple, banana, apple, banana, apple)
 
-      @agent.convert_catalog(catalog, 10)
+      configurer.run
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: "Failed to apply catalog: Catalog environment didn't stabilize after 4 fetches, aborting run"))
     end
+  end
 
-    it "should record the passed retrieval time with the RAL catalog" do
-      expect(ral_catalog).to receive(:retrieval_duration=).with(10)
+  describe "when converting the catalog" do
+    it "converts Puppet::Resource into Puppet::Type::Notify" do
+      expect(configurer).to receive(:apply_catalog) do |ral, _|
+        expect(ral.resources).to contain(an_instance_of(Puppet::Type::Notify))
+      end
 
-      @agent.convert_catalog(catalog, 10)
+      configurer.run(catalog: catalog)
     end
 
-    it "should write the RAL catalog's class file" do
-      expect(ral_catalog).to receive(:write_class_file)
+    it "adds default schedules" do
+      expect(configurer).to receive(:apply_catalog) do |ral, _|
+        expect(ral.resources.map(&:to_ref)).to contain(%w{Schedule[puppet] Schedule[hourly] Schedule[daily] Schedule[weekly] Schedule[monthly] Schedule[never]})
+      end
+
+      configurer.run
+    end
+
+    it "records the retrieval duration to the catalog" do
+      expect(configurer).to receive(:apply_catalog) do |ral, _|
+        expect(ral.retrieval_duration).to be_an_instance_of(Float)
+      end
 
-      @agent.convert_catalog(catalog, 10)
+      configurer.run
     end
 
-    it "should write the RAL catalog's resource file" do
-      expect(ral_catalog).to receive(:write_resource_file)
+    it "writes the class file containing applied settings classes" do
+      expect(File).to_not be_exist(Puppet[:classfile])
+
+      configurer.run
 
-      @agent.convert_catalog(catalog, 10)
+      expect(File.read(Puppet[:classfile]).chomp).to eq('settings')
     end
 
-    it "should set catalog conversion time on the report" do
-      report = Puppet::Transaction::Report.new
+    it "writes an empty resource file since no resources are 'managed'" do
+      expect(File).to_not be_exist(Puppet[:resourcefile])
 
-      expect(report).to receive(:add_times).with(:convert_catalog, kind_of(Numeric))
-      @agent.convert_catalog(catalog, 10, {:report => report})
+      configurer.run
+
+      expect(File.read(Puppet[:resourcefile]).chomp).to eq("")
+    end
+
+    it "adds the conversion time to the report" do
+      configurer.run(report: report)
+
+      expect(report.metrics['time']['convert_catalog']).to be_an_instance_of(Float)
     end
   end
 
@@ -995,66 +993,62 @@ describe Puppet::Configurer do
   describe "when attempting failover" do
     it "should not failover if server_list is not set" do
       Puppet.settings[:server_list] = []
-      expect(@agent).not_to receive(:find_functional_server)
-      @agent.run
+      configurer.run
     end
 
     it "should not failover during an apply run" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      expect(@agent).not_to receive(:find_functional_server)
-      catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
-      @agent.run :catalog => catalog
+      catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+      configurer.run(catalog: catalog)
     end
 
     it "should select a server when it receives 200 OK response" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      response = Net::HTTPOK.new(nil, 200, 'OK')
-      allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: response))
-      allow(@agent).to receive(:run_internal)
+
+      stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: 200)
 
       options = {}
-      @agent.run(options)
+      configurer.run(options)
       expect(options[:report].master_used).to eq('myserver:123')
     end
 
-    it "queries the simple status for the 'master' service" do
-      Puppet.settings[:server_list] = ["myserver:123"]
-      response = Net::HTTPOK.new(nil, 200, 'OK')
-      http = double('request')
-      expect(http).to receive(:get).with('/status/v1/simple/master').and_return(response)
-      allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(http)
-      allow(@agent).to receive(:run_internal)
-
-      @agent.run
-    end
-
     it "should report when a server is unavailable" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      response = Net::HTTPInternalServerError.new(nil, 500, 'Internal Server Error')
-      allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: response))
 
+      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{ @agent.run }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list/)
+
+      expect {
+        configurer.run
+      }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list:/)
     end
 
     it "should error when no servers in 'server_list' are reachable" do
-      Puppet.settings[:server_list] = ["myserver:123"]
-      error = Net::HTTPError.new(400, 'dummy server communication error')
-      allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: error))
+      Puppet.settings[:server_list] = "myserver:123,someotherservername"
 
-      options = {}
-      expect{ @agent.run(options) }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list/)
-      expect(options[:report].master_used).to be_nil
+      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'/)
     end
 
     it "should not make multiple node requests when the server is found" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      response = Net::HTTPOK.new(nil, 200, 'OK')
 
-      expect(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: response))
-      allow(@agent).to receive(:run_internal)
+      Puppet::Node.indirection.terminus_class = :rest
+      Puppet::Resource::Catalog.indirection.terminus_class = :rest
+
+      stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: 200)
+      stub_request(:post, %r{https://myserver:123/puppet/v3/catalog}).to_return(status: 200)
+      node_request = stub_request(:get, %r{https://myserver:123/puppet/v3/node/}).to_return(status: 200)
+
+      configurer.run
 
-      @agent.run
+      expect(node_request).to have_been_requested.once
     end
   end
 end