puppet 4.1.0 → 5.0.0

data/spec/unit/configurer_spec.rb

@@ -117,7 +117,7 @@ describe Puppet::Configurer do
     end
 
     it "should initialize a transaction report if one is not provided" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns report
 
       @agent.run
@@ -127,14 +127,14 @@ describe Puppet::Configurer do
       Puppet[:node_name_fact] = 'my_name_fact'
       @facts.values = {'my_name_fact' => 'node_name_from_fact'}
 
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
 
       @agent.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("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.stubs(:new).returns report
       @catalog.expects(:apply).with{|options| options[:report] == report}
 
@@ -142,14 +142,14 @@ describe Puppet::Configurer do
     end
 
     it "should use the provided report if it was passed one" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       @catalog.expects(:apply).with {|options| options[:report] == report}
 
       @agent.run(:report => report)
     end
 
     it "should set the report as a log destination" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
 
       report.expects(:<<).with(instance_of(Puppet::Util::Log)).at_least_once
 
@@ -199,8 +199,19 @@ describe Puppet::Configurer do
       @agent.run
     end
 
+    it "should create report with passed transaction_uuid and job_id" do
+      @agent = Puppet::Configurer.new(Puppet::Configurer::DownloaderFactory.new, "test_tuuid", "test_jid")
+      @agent.stubs(:init_storage)
+
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
+      Puppet::Transaction::Report.expects(:new).with(anything, anything, 'test_tuuid', 'test_jid').returns(report)
+      @agent.expects(:send_report).with(report)
+
+      @agent.run
+    end
+
     it "should send the report" do
-      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
@@ -213,7 +224,7 @@ describe Puppet::Configurer do
     it "should send the transaction report even if the catalog could not be retrieved" do
       @agent.expects(:retrieve_catalog).returns nil
 
-      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
@@ -226,7 +237,7 @@ describe Puppet::Configurer do
     it "should send the transaction report even if there is a failure" do
       @agent.expects(:retrieve_catalog).raises "whatever"
 
-      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
@@ -237,7 +248,7 @@ describe Puppet::Configurer do
     end
 
     it "should remove the report as a log destination when the run is finished" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       @agent.run
@@ -246,7 +257,7 @@ describe Puppet::Configurer do
     end
 
     it "should return the report exit_status as the result of the run" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
       report.expects(:exit_status).returns(1234)
 
@@ -254,7 +265,7 @@ describe Puppet::Configurer do
     end
 
     it "should send the transaction report even if the pre-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
@@ -265,7 +276,7 @@ describe Puppet::Configurer do
     end
 
     it "should include the pre-run command failure in the report" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
@@ -276,7 +287,7 @@ describe Puppet::Configurer do
     end
 
     it "should send the transaction report even if the post-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
@@ -287,7 +298,7 @@ describe Puppet::Configurer do
     end
 
     it "should include the post-run command failure in the report" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
@@ -308,7 +319,7 @@ describe Puppet::Configurer do
     end
 
     it "should finalize the report" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       report.expects(:finalize_report)
@@ -316,7 +327,7 @@ describe Puppet::Configurer do
     end
 
     it "should not apply the catalog if the pre-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
@@ -329,7 +340,7 @@ describe Puppet::Configurer do
     end
 
     it "should apply the catalog, send the report, and return nil if the post-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
@@ -357,7 +368,7 @@ describe Puppet::Configurer do
     end
 
     it "should fix the report if the server specifies a new environment in the catalog" do
-      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
@@ -369,12 +380,40 @@ describe Puppet::Configurer do
       expect(report.environment).to eq("second_env")
     end
 
-    it "should clear the global caches" do
-      $env_module_directories = false
+    it "sends the transaction uuid in a catalog request" do
+      @agent.instance_variable_set(:@transaction_uuid, 'aaa')
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => 'aaa'))
+      @agent.run
+    end
 
+    it "sends the transaction uuid in a catalog request" do
+      @agent.instance_variable_set(:@job_id, 'aaa')
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:job_id => 'aaa'))
       @agent.run
+    end
 
-      expect($env_module_directories).to eq(nil)
+    it "sets the static_catalog query param to true in a catalog request" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:static_catalog => true))
+      @agent.run
+    end
+
+    it "sets the checksum_type query param to the default supported_checksum_types in a catalog request" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything,
+        has_entries(:checksum_type => 'md5.sha256'))
+      @agent.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
+      @agent.stubs(:init_storage)
+      @agent.stubs(:download_plugins)
+      @agent.stubs(:send_report)
+      @agent.stubs(:save_last_run_summary)
+
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:checksum_type => 'sha256'))
+      @agent.run
     end
 
     describe "when not using a REST terminus for catalogs" do
@@ -402,6 +441,14 @@ describe Puppet::Configurer do
     end
   end
 
+  describe "when initialized with a transaction_uuid" do
+    it "stores it" do
+      SecureRandom.expects(:uuid).never
+      configurer = Puppet::Configurer.new(Puppet::Configurer::DownloaderFactory.new, 'foo')
+      expect(configurer.instance_variable_get(:@transaction_uuid) == 'foo')
+    end
+  end
+
   describe "when sending a report" do
     include PuppetSpec::Files
 
@@ -410,7 +457,7 @@ describe Puppet::Configurer do
       @configurer = Puppet::Configurer.new
       Puppet[:lastrunfile] = tmpfile('last_run_file')
 
-      @report = Puppet::Transaction::Report.new("apply")
+      @report = Puppet::Transaction::Report.new
       Puppet[:reports] = "none"
     end
 
@@ -531,19 +578,55 @@ describe Puppet::Configurer do
       Puppet::Node.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => anything)).twice
       @agent.run
     end
+
+    it "sends an explicitly configured environment request" do
+      Puppet.settings.expects(:set_by_config?).with(:environment).returns(true)
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => Puppet[:environment])).twice
+      @agent.run
+    end
+
+    it "does not send a configured_environment when using the default" do
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => nil)).twice
+      @agent.run
+    end
+  end
+
+  def expects_new_catalog_only(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
+  end
+
+  def expects_cached_catalog_only(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
+  end
+
+  def expects_fallback_to_cached_catalog(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+  end
+
+  def expects_fallback_to_new_catalog(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+  end
+
+  def expects_neither_new_or_cached_catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
   end
 
   describe "when retrieving a catalog" do
     before do
       Puppet.settings.stubs(:use).returns(true)
       @agent.stubs(:facts_for_uploading).returns({})
+      @agent.stubs(:download_plugins)
 
-      @catalog = Puppet::Resource::Catalog.new
+      # 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
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
-
-      @agent.stubs(:convert_catalog).returns @catalog
     end
 
     describe "and configured to only retrieve a catalog from the cache" do
@@ -552,18 +635,123 @@ describe Puppet::Configurer do
       end
 
       it "should first look in the cache for a catalog" do
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
+        expects_cached_catalog_only(@catalog)
 
         expect(@agent.retrieve_catalog({})).to eq(@catalog)
       end
 
+      it "should not make a node request or pluginsync when a cached catalog is successfully retrieved" do
+        Puppet::Node.indirection.expects(:find).never
+        expects_cached_catalog_only(@catalog)
+        @agent.expects(:download_plugins).never
+
+        @agent.run
+      end
+
+      it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
+        Puppet::Node.indirection.expects(:find).returns nil
+        expects_fallback_to_new_catalog(@catalog)
+        @agent.expects(:download_plugins)
+
+        @agent.run
+      end
+
+      it "should set its cached_catalog_status to 'explicitly_requested'" do
+        expects_cached_catalog_only(@catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@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'))
+        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
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+        expects_fallback_to_new_catalog(@catalog)
 
         expect(@agent.retrieve_catalog({})).to eq(@catalog)
       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)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+      end
+
+      it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
+        Puppet::Node.indirection.expects(:find).returns(nil)
+        expects_neither_new_or_cached_catalog
+
+        @agent.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'))
+        expects_cached_catalog_only(cached_catalog)
+
+        Puppet.expects(:info).with("Using cached catalog from environment 'second_env'")
+        expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+      end
+    end
+
+    describe "and strict environment mode is set" do
+      before do
+        @catalog.stubs(:to_ral).returns(@catalog)
+        @catalog.stubs(:write_class_file)
+        @catalog.stubs(:write_resource_file)
+        @agent.stubs(:send_report)
+        @agent.stubs(:save_last_run_summary)
+        Puppet.settings[:strict_environment_mode] = true
+      end
+
+      it "should not make a node request" do
+        Puppet::Node.indirection.expects(:find).never
+
+        @agent.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.expects(: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
+      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)
+
+        expect(@agent.run).to eq(0)
+      end
+
+      describe "and a cached catalog is explicitly requested" do
+        before do
+          Puppet.settings[:use_cached_catalog] = true
+        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.expects(: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
+        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)
+
+          expect(@agent.run).to eq(0)
+        end
+      end
     end
 
     it "should use the Catalog class to get its catalog" do
@@ -572,6 +760,13 @@ describe Puppet::Configurer do
       @agent.retrieve_catalog({})
     end
 
+    it "should set its cached_catalog_status to 'not_used' when downloading a new catalog" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+    end
+
     it "should use its node_name_value to retrieve the catalog" do
       Facter.stubs(:value).returns "eh"
       Puppet.settings[:node_name_value] = "myhost.domain.com"
@@ -587,17 +782,21 @@ describe Puppet::Configurer do
     end
 
     it "should log and return the cached catalog when no catalog can be retrieved from the server" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-
-      Puppet.expects(:notice)
+      expects_fallback_to_cached_catalog(@catalog)
 
+      Puppet.expects(:info).with("Using cached catalog from environment 'production'")
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     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)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@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
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
+      expects_new_catalog_only(@catalog)
 
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
@@ -609,72 +808,187 @@ describe Puppet::Configurer do
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
+    it "should set its cached_catalog_status to 'on_failure' when retrieving the remote catalog throws an exception" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@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
       Puppet[:usecacheonfailure] = false
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
 
-      Puppet.expects(:warning)
+      Puppet.expects(:warning).with('Not using cache on failed catalog')
 
       expect(@agent.retrieve_catalog({})).to be_nil
     end
 
-    it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
+    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
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
 
-      expect(@agent.retrieve_catalog({})).to be_nil
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
     end
 
-    it "should convert the catalog before returning" do
-      Puppet::Resource::Catalog.indirection.stubs(:find).returns @catalog
+    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
 
-      @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
-      expect(@agent.retrieve_catalog({})).to eq("converted catalog")
+      expect(@agent.retrieve_catalog({})).to be_nil
     end
 
-    it "should return nil if there is an error while retrieving the catalog" do
-      Puppet::Resource::Catalog.indirection.expects(:find).at_least_once.raises "eh"
+    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')
 
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      Puppet.expects(:err).with("Not using cached catalog because its environment 'second_env' does not match 'production'")
       expect(@agent.retrieve_catalog({})).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')
+
+      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)
+    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)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
   end
 
   describe "when converting the catalog" do
     before do
       Puppet.settings.stubs(:use).returns(true)
 
-      @catalog = Puppet::Resource::Catalog.new
-      @oldcatalog = stub 'old_catalog', :to_ral => @catalog
+      catalog.stubs(:to_ral).returns ral_catalog
     end
 
-    it "should convert the catalog to a RAL-formed catalog" do
-      @oldcatalog.expects(:to_ral).returns @catalog
+    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)) }
 
-      expect(@agent.convert_catalog(@oldcatalog, 10)).to equal(@catalog)
+    it "should convert the catalog to a RAL-formed catalog" do
+      expect(@agent.convert_catalog(catalog, 10)).to equal(ral_catalog)
     end
 
     it "should finalize the catalog" do
-      @catalog.expects(:finalize)
+      ral_catalog.expects(:finalize)
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should record the passed retrieval time with the RAL catalog" do
-      @catalog.expects(:retrieval_duration=).with 10
+      ral_catalog.expects(:retrieval_duration=).with 10
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should write the RAL catalog's class file" do
-      @catalog.expects(:write_class_file)
+      ral_catalog.expects(:write_class_file)
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should write the RAL catalog's resource file" do
-      @catalog.expects(:write_resource_file)
+      ral_catalog.expects(:write_resource_file)
+
+      @agent.convert_catalog(catalog, 10)
+    end
+  end
+
+  describe "when determining whether to pluginsync" do
+    it "should default to Puppet[:pluginsync] when explicitly set by the commandline" do
+      Puppet.settings[:pluginsync] = false
+      Puppet.settings.expects(:set_by_cli?).returns(true)
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+
+    it "should default to Puppet[:pluginsync] when explicitly set by config" do
+      Puppet.settings[:pluginsync] = false
+      Puppet.settings.expects(:set_by_config?).returns(true)
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+
+    it "should be true if use_cached_catalog is false" do
+      Puppet.settings[:use_cached_catalog] = false
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      expect(described_class).to be_should_pluginsync
+    end
+
+    it "should be false if use_cached_catalog is true" do
+      Puppet.settings[:use_cached_catalog] = true
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+  end
+
+  describe "when attempting failover" do
+    it "should not failover if server_list is not set" do
+      Puppet.settings[:server_list] = []
+      @agent.expects(:find_functional_server).never
+      @agent.run
+    end
+
+    it "should not failover during an apply run" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      @agent.expects(:find_functional_server).never
+      catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+      @agent.run :catalog => catalog
+    end
+
+    it "should select a server when provided" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
+      Puppet::Network::HTTP::Pool.expects(:new).returns(pool)
+      Puppet.expects(:override).with({:http_pool => pool}).yields
+      Puppet.expects(:override).with({:server => "myserver", :serverport => '123'}).twice.yields
+      Puppet::Node.indirection.expects(:find).returns(nil)
+      @agent.expects(:run_internal).returns(nil)
+      @agent.run
+    end
+
+    it "should fallback to an empty server when failover fails" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
+      Puppet::Network::HTTP::Pool.expects(:new).returns(pool)
+      Puppet.expects(:override).with({:http_pool => pool}).yields
+      Puppet.expects(:override).with({:server => "myserver", :serverport => '123'}).yields
+      Puppet.expects(:override).with({:server => nil, :serverport => nil}).yields
+      error = Net::HTTPError.new(400, 'dummy server communication error')
+      Puppet::Node.indirection.expects(:find).raises(error)
+      @agent.expects(:run_internal).returns(nil)
+      @agent.run
+    end
+
+    it "should not make multiple node requets when the server is found" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      Puppet::Node.indirection.expects(:find).returns("mynode").once
+      @agent.expects(:prepare_and_retrieve_catalog).returns(nil)
+      @agent.run
     end
   end
 end