puppet 6.12.0-x64-mingw32 → 6.17.0-x64-mingw32

data/spec/unit/application/agent_spec.rb

@@ -12,16 +12,16 @@ describe Puppet::Application::Agent do
   before :each do
     @puppetd = Puppet::Application[:agent]
 
-    @daemon = Puppet::Daemon.new(nil)
+    @agent = double('agent')
+    allow(Puppet::Agent).to receive(:new).and_return(@agent)
+
+    @daemon = Puppet::Daemon.new(@agent, nil)
     allow(@daemon).to receive(:daemonize)
     allow(@daemon).to receive(:start)
     allow(@daemon).to receive(:stop)
     allow(Puppet::Daemon).to receive(:new).and_return(@daemon)
     Puppet[:daemonize] = false
 
-    @agent = double('agent')
-    allow(Puppet::Agent).to receive(:new).and_return(@agent)
-
     @puppetd.preinit
     allow(Puppet::Util::Log).to receive(:newdestination)
 
@@ -122,6 +122,10 @@ describe Puppet::Application::Agent do
       end
     end
 
+    it "should log the agent start time" do
+      expect(@puppetd.options[:start_time]).to be_a(Time)
+    end
+
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
       allow(@agent).to receive(:run).and_return(2)
       Puppet[:onetime] = true
@@ -505,7 +509,7 @@ describe Puppet::Application::Agent do
 
       it "should run the agent with the supplied job_id" do
         @puppetd.options[:job_id] = 'special id'
-        expect(@agent).to receive(:run).with(:job_id => 'special id').and_return(:report)
+        expect(@agent).to receive(:run).with(hash_including(:job_id => 'special id')).and_return(:report)
 
         expect { execute_agent }.to exit_with 0
       end

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

data/spec/unit/configurer/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

@@ -4,20 +4,18 @@ require 'webmock/rspec'
 
 describe Puppet::Configurer do
   before do
-    Puppet::Node::Facts.indirection.terminus_class = :memory
-    Puppet::Node::Facts.indirection.save(facts)
-
     Puppet[:server] = "puppetmaster"
     Puppet[:report] = true
 
     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("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
+  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(Puppet[:node_name_value]) }
+  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
@@ -104,6 +102,7 @@ describe Puppet::Configurer do
     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'}
       Puppet::Node::Facts.indirection.save(facts)
@@ -149,7 +148,7 @@ describe Puppet::Configurer do
       configurer = Puppet::Configurer.new("test_tuuid", "test_jid")
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      expect(Puppet::Transaction::Report).to receive(:new).with(anything, anything, 'test_tuuid', 'test_jid').and_return(report)
+      expect(Puppet::Transaction::Report).to receive(:new).with(anything, anything, 'test_tuuid', 'test_jid', anything).and_return(report)
       expect(configurer).to receive(:send_report).with(report)
 
       configurer.run
@@ -319,7 +318,7 @@ describe Puppet::Configurer do
     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'))
+      catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote('second_env'))
       expect(configurer).to receive(:retrieve_catalog).and_return(catalog).twice
 
       configurer.run
@@ -614,7 +613,7 @@ describe Puppet::Configurer do
       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)
 
         options = {}
@@ -647,7 +646,7 @@ describe Puppet::Configurer do
       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)
@@ -705,7 +704,7 @@ describe Puppet::Configurer do
         Puppet[:environment] = 'second_env'
         configurer = Puppet::Configurer.new
 
-        catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote("production"))
+        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")
@@ -727,7 +726,7 @@ describe Puppet::Configurer do
           Puppet[:environment] = 'second_env'
           configurer = Puppet::Configurer.new
 
-          catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote("production"))
+          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")
@@ -827,7 +826,7 @@ describe Puppet::Configurer do
     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'))
+      cached_catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote('second_env'))
 
       expects_fallback_to_cached_catalog(cached_catalog)
 
@@ -837,7 +836,7 @@ describe Puppet::Configurer do
     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'))
+      cached_catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote('second_env'))
 
       expects_fallback_to_cached_catalog(cached_catalog)
 
@@ -857,7 +856,7 @@ describe Puppet::Configurer do
     it "should not update the cached catalog in noop mode" do
       Puppet[:noop] = true
 
-      stub_request(:get, %r{/puppet/v3/catalog}).to_return(:status => 200, :body => catalog.render(:json), :headers => {'Content-Type' => 'application/json'})
+      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)
@@ -871,7 +870,7 @@ describe Puppet::Configurer do
       Puppet[:noop] = false
       Puppet[:log_level] = 'info'
 
-      stub_request(:get, %r{/puppet/v3/catalog}).to_return(:status => 200, :body => catalog.render(:json), :headers => {'Content-Type' => 'application/json'})
+      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])
@@ -884,7 +883,7 @@ describe Puppet::Configurer do
     end
 
     it "successfully applies the catalog without a cache" do
-      stub_request(:get, %r{/puppet/v3/catalog}).to_return(:status => 200, :body => catalog.render(:json), :headers => {'Content-Type' => 'application/json'})
+      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
 
@@ -999,7 +998,7 @@ describe Puppet::Configurer do
 
     it "should not failover during an apply run" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+      catalog = Puppet::Resource::Catalog.new(node_name, Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
       configurer.run(catalog: catalog)
     end
 
@@ -1044,7 +1043,7 @@ describe Puppet::Configurer do
       Puppet::Resource::Catalog.indirection.terminus_class = :rest
 
       stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: 200)
-      stub_request(:get, %r{https://myserver:123/puppet/v3/catalog}).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