puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

data/spec/integration/util/windows/process_spec.rb

@@ -31,4 +31,35 @@ describe "Puppet::Util::Windows::Process", :if => Puppet.features.microsoft_wind
       expect { Puppet::Util::Windows::Process.lookup_privilege_value('foo') }.to raise_error(Puppet::Util::Windows::Error, fail_msg)
     end
   end
+
+  describe "when setting environment variables" do
+    it "can properly handle env var values with = in them" do
+      begin
+        name = SecureRandom.uuid
+        value = 'foo=bar'
+
+        Puppet::Util::Windows::Process.set_environment_variable(name, value)
+
+        env = Puppet::Util::Windows::Process.get_environment_strings
+
+        expect(env[name]).to eq(value)
+      ensure
+        Puppet::Util::Windows::Process.set_environment_variable(name, nil)
+      end
+    end
+
+    it "can properly handle empty env var values" do
+      begin
+        name = SecureRandom.uuid
+
+        Puppet::Util::Windows::Process.set_environment_variable(name, '')
+
+        env = Puppet::Util::Windows::Process.get_environment_strings
+
+        expect(env[name]).to eq('')
+      ensure
+        Puppet::Util::Windows::Process.set_environment_variable(name, nil)
+      end
+    end
+  end
 end

data/spec/integration/util/windows/security_spec.rb

@@ -14,13 +14,13 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
   before :all do
     @sids = {
       :current_user => Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name),
-      :system => Win32::Security::SID::LocalSystem,
-      :administrators => Win32::Security::SID::BuiltinAdministrators,
+      :system => Puppet::Util::Windows::SID::LocalSystem,
+      :administrators => Puppet::Util::Windows::SID::BuiltinAdministrators,
       :guest => Puppet::Util::Windows::SID.name_to_sid("Guest"),
-      :users => Win32::Security::SID::BuiltinUsers,
-      :power_users => Win32::Security::SID::PowerUsers,
-      :none => Win32::Security::SID::Nobody,
-      :everyone => Win32::Security::SID::Everyone
+      :users => Puppet::Util::Windows::SID::BuiltinUsers,
+      :power_users => Puppet::Util::Windows::SID::PowerUsers,
+      :none => Puppet::Util::Windows::SID::Nobody,
+      :everyone => Puppet::Util::Windows::SID::Everyone
     }
     # The TCP/IP NetBIOS Helper service (aka 'lmhosts') has ended up
     # disabled on some VMs for reasons we couldn't track down. This

data/spec/integration/util/windows/user_spec.rb

@@ -67,7 +67,7 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
         yield
       }.to raise_error { |error|
         expect(error).to be_a(Puppet::Util::Windows::Error)
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
         # ERROR_LOGON_FAILURE 1326
         expect(error.code).to eq(1326)
       }

data/spec/integration/util_spec.rb

@@ -27,9 +27,10 @@ describe Puppet::Util do
       expect { Puppet::Util::Execution.execute(command) }.to raise_error(Puppet::ExecutionFailure, /Execution of '#{command}' returned 43: /)
       expect($CHILD_STATUS.exitstatus).to eq(43)
     end
+  end
 
-    it "replace_file should preserve original ACEs from existing replaced file on Windows",
-      :if => Puppet.features.microsoft_windows? do
+  describe "#replace_file on Windows", :if => Puppet.features.microsoft_windows? do
+    it "replace_file should preserve original ACEs from existing replaced file on Windows" do
 
       file = tmpfile("somefile")
       FileUtils.touch(file)
@@ -54,8 +55,7 @@ describe Puppet::Util do
       expect(replaced_sd.dacl).to eq(expected_sd.dacl)
     end
 
-    it "replace_file should use reasonable default ACEs on a new file on Windows",
-      :if => Puppet.features.microsoft_windows? do
+    it "replace_file should use reasonable default ACEs on a new file on Windows" do
 
       dir = tmpdir('DACL_playground')
       protected_sd = Puppet::Util::Windows::Security.get_security_descriptor(dir)
@@ -76,36 +76,58 @@ describe Puppet::Util do
 
       expect(new_sd.dacl).to eq(expected_sd.dacl)
     end
-  end
 
-  it "replace_file should work with filenames that include - and . (PUP-1389)", :if => Puppet.features.microsoft_windows? do
-    expected_content = 'some content'
-    dir = tmpdir('ReplaceFile_playground')
-    destination_file = File.join(dir, 'some-file.xml')
+    it "replace_file should work with filenames that include - and . (PUP-1389)" do
+      expected_content = 'some content'
+      dir = tmpdir('ReplaceFile_playground')
+      destination_file = File.join(dir, 'some-file.xml')
+
+      Puppet::Util.replace_file(destination_file, nil) do |temp_file|
+          temp_file.open
+          temp_file.write(expected_content)
+      end
 
-    Puppet::Util.replace_file(destination_file, nil) do |temp_file|
-        temp_file.open
-        temp_file.write(expected_content)
+      actual_content = File.read(destination_file)
+      expect(actual_content).to eq(expected_content)
     end
 
-    actual_content = File.read(destination_file)
-    expect(actual_content).to eq(expected_content)
+    it "replace_file should work with filenames that include special characters (PUP-1389)" do
+      expected_content = 'some content'
+      dir = tmpdir('ReplaceFile_playground')
+      # http://www.fileformat.info/info/unicode/char/00e8/index.htm
+      # dest_name = "somèfile.xml"
+      dest_name = "som\u00E8file.xml"
+      destination_file = File.join(dir, dest_name)
+
+      Puppet::Util.replace_file(destination_file, nil) do |temp_file|
+          temp_file.open
+          temp_file.write(expected_content)
+      end
+
+      actual_content = File.read(destination_file)
+      expect(actual_content).to eq(expected_content)
+    end
   end
 
-  it "replace_file should work with filenames that include special characters (PUP-1389)", :if => Puppet.features.microsoft_windows? do
-    expected_content = 'some content'
-    dir = tmpdir('ReplaceFile_playground')
-    # http://www.fileformat.info/info/unicode/char/00e8/index.htm
-    # dest_name = "somèfile.xml"
-    dest_name = "som\u00E8file.xml"
-    destination_file = File.join(dir, dest_name)
-
-    Puppet::Util.replace_file(destination_file, nil) do |temp_file|
-        temp_file.open
-        temp_file.write(expected_content)
+  describe "#which on Windows", :if => Puppet.features.microsoft_windows? do
+    let (:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
+    let (:filename) { 'foo.exe' }
+    let (:filepath) { File.expand_path('C:\\' + rune_utf8 + '\\' + filename) }
+
+    before :each do
+      FileTest.stubs(:file?).returns false
+      FileTest.stubs(:file?).with(filepath).returns true
+
+      FileTest.stubs(:executable?).returns false
+      FileTest.stubs(:executable?).with(filepath).returns true
     end
 
-    actual_content = File.read(destination_file)
-    expect(actual_content).to eq(expected_content)
+    it "should be able to use UTF8 characters in the path" do
+      path = "C:\\" + rune_utf8 + "#{File::PATH_SEPARATOR}c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows"
+      Puppet::Util.withenv( { "PATH" => path } , :windows) do
+        expect(Puppet::Util.which(filename)).to eq(filepath)
+      end
+    end
   end
+
 end

data/spec/lib/puppet_spec/compiler.rb

@@ -46,4 +46,21 @@ module PuppetSpec::Compiler
     relationships.traverse { |resource| order_seen << resource.ref }
     order_seen
   end
+
+  def collect_notices(code, node = Puppet::Node.new('foonode'))
+    Puppet[:code] = code
+    compiler = Puppet::Parser::Compiler.new(node)
+    logs = []
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      yield(compiler)
+    end
+    logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
+    logs
+  end
+
+  def eval_and_collect_notices(code, node = Puppet::Node.new('foonode'))
+    collect_notices(code, node) do |compiler|
+      compiler.compile
+    end
+  end
 end

data/spec/lib/puppet_spec/files.rb

@@ -28,7 +28,7 @@ module PuppetSpec::Files
   def self.tmpfile(name, dir = nil)
     # Generate a temporary file, just for the name...
     source = dir ? Tempfile.new(name, dir) : Tempfile.new(name)
-    path = source.path
+    path = source.path.encode(Encoding::UTF_8)
     source.close!
 
     record_tmp(File.expand_path(path))
@@ -59,7 +59,7 @@ module PuppetSpec::Files
 
   def tmpdir(name) PuppetSpec::Files.tmpdir(name) end
   def self.tmpdir(name)
-    dir = Dir.mktmpdir(name)
+    dir = Dir.mktmpdir(name).encode!(Encoding::UTF_8)
 
     record_tmp(dir)
 

data/spec/lib/puppet_spec/pops.rb

@@ -13,4 +13,17 @@ module PuppetSpec::Pops
       "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to not contain issue #{expected.issue_code}"
     end
   end
+
+  # Checks if an Acceptor has any issues
+  matcher :have_any_issues do
+    match do |actual|
+      !actual.diagnostics.empty?
+    end
+    failure_message do |actual|
+      'expected Acceptor[] to contain at least one issue'
+    end
+    failure_message_when_negated do |actual|
+      "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to not contain any issues"
+    end
+  end
 end

data/spec/shared_behaviours/iterative_functions.rb

@@ -16,7 +16,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
       compile_to_catalog(<<-MANIFEST)
         3.14.#{func} |$k, $v| {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /must be something enumerable/)
+    end.to raise_error(Puppet::Error, /expects an Iterable value, got Float/)
   end
 
   it 'raises an error when called with any parameters besides a block' do

data/spec/shared_contexts/types_setup.rb

@@ -0,0 +1,96 @@
+shared_context 'types_setup' do
+
+  # Do not include the special type Unit in this list
+  def all_types
+    [ Puppet::Pops::Types::PAnyType,
+      Puppet::Pops::Types::PUndefType,
+      Puppet::Pops::Types::PNotUndefType,
+      Puppet::Pops::Types::PDataType,
+      Puppet::Pops::Types::PScalarType,
+      Puppet::Pops::Types::PStringType,
+      Puppet::Pops::Types::PNumericType,
+      Puppet::Pops::Types::PIntegerType,
+      Puppet::Pops::Types::PFloatType,
+      Puppet::Pops::Types::PRegexpType,
+      Puppet::Pops::Types::PBooleanType,
+      Puppet::Pops::Types::PCollectionType,
+      Puppet::Pops::Types::PArrayType,
+      Puppet::Pops::Types::PHashType,
+      Puppet::Pops::Types::PIterableType,
+      Puppet::Pops::Types::PIteratorType,
+      Puppet::Pops::Types::PRuntimeType,
+      Puppet::Pops::Types::PHostClassType,
+      Puppet::Pops::Types::PResourceType,
+      Puppet::Pops::Types::PPatternType,
+      Puppet::Pops::Types::PEnumType,
+      Puppet::Pops::Types::PVariantType,
+      Puppet::Pops::Types::PStructType,
+      Puppet::Pops::Types::PTupleType,
+      Puppet::Pops::Types::PCallableType,
+      Puppet::Pops::Types::PType,
+      Puppet::Pops::Types::POptionalType,
+      Puppet::Pops::Types::PDefaultType,
+      Puppet::Pops::Types::PTypeReferenceType,
+      Puppet::Pops::Types::PTypeAliasType,
+    ]
+  end
+
+  def scalar_types
+    # PVariantType is also scalar, if its types are all Scalar
+    [
+      Puppet::Pops::Types::PScalarType,
+      Puppet::Pops::Types::PStringType,
+      Puppet::Pops::Types::PNumericType,
+      Puppet::Pops::Types::PIntegerType,
+      Puppet::Pops::Types::PFloatType,
+      Puppet::Pops::Types::PRegexpType,
+      Puppet::Pops::Types::PBooleanType,
+      Puppet::Pops::Types::PPatternType,
+      Puppet::Pops::Types::PEnumType,
+    ]
+  end
+
+  def numeric_types
+    # PVariantType is also numeric, if its types are all numeric
+    [
+      Puppet::Pops::Types::PNumericType,
+      Puppet::Pops::Types::PIntegerType,
+      Puppet::Pops::Types::PFloatType,
+    ]
+  end
+
+  def string_types
+    # PVariantType is also string type, if its types are all compatible
+    [
+      Puppet::Pops::Types::PStringType,
+      Puppet::Pops::Types::PPatternType,
+      Puppet::Pops::Types::PEnumType,
+    ]
+  end
+
+  def collection_types
+    # PVariantType is also string type, if its types are all compatible
+    [
+      Puppet::Pops::Types::PCollectionType,
+      Puppet::Pops::Types::PHashType,
+      Puppet::Pops::Types::PArrayType,
+      Puppet::Pops::Types::PStructType,
+      Puppet::Pops::Types::PTupleType,
+    ]
+  end
+
+  def data_compatible_types
+    result = scalar_types
+    result << Puppet::Pops::Types::PDataType
+    result << array_t(types::PDataType::DEFAULT)
+    result << types::TypeFactory.hash_of_data
+    result << Puppet::Pops::Types::PUndefType
+    result << not_undef_t(types::PDataType.new)
+    result << constrained_tuple_t(range_t(0, nil), types::PDataType::DEFAULT)
+    result
+  end
+
+  def type_from_class(c)
+    c.is_a?(Class) ? c::DEFAULT : c
+  end
+end

data/spec/unit/agent_spec.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/agent'
+require 'puppet/configurer'
 
 class AgentTestClient
   def run

data/spec/unit/application/agent_spec.rb

@@ -343,12 +343,22 @@ describe Puppet::Application::Agent do
 
     it "should not set catalog cache class if :catalog_cache_terminus is explicitly nil" do
       Puppet[:catalog_cache_terminus] = nil
+      Puppet::Resource::Catalog.indirection.unstub(:cache_class=)
       Puppet::Resource::Catalog.indirection.expects(:cache_class=).never
 
       @puppetd.initialize_app_defaults
       @puppetd.setup
     end
 
+    it "should set catalog cache class to nil during a noop run" do
+      Puppet[:catalog_cache_terminus] = "json"
+      Puppet[:noop] = true
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(nil)
+
+      @puppetd.initialize_app_defaults
+      @puppetd.setup
+    end
+
     it "should default facts_terminus setting to 'facter'" do
       @puppetd.initialize_app_defaults
       expect(Puppet[:facts_terminus]).to eq(:facter)

data/spec/unit/application/apply_spec.rb

@@ -478,4 +478,13 @@ describe Puppet::Application::Apply do
     @apply.initialize_app_defaults
     @apply.setup
   end
+
+  it "should set catalog cache class to nil during a noop run" do
+    Puppet[:catalog_cache_terminus] = "json"
+    Puppet[:noop] = true
+    Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(nil)
+
+    @apply.initialize_app_defaults
+    @apply.setup
+  end
 end

data/spec/unit/configurer/downloader_spec.rb

@@ -82,13 +82,13 @@ describe Puppet::Configurer::Downloader do
       expect(file[:source_permissions]).to eq(:ignore)
     end
 
-    it "should allow source_permissions to be overridden" do
-      file = generate_file_resource(:source_permissions => :use)
+    describe "on POSIX", :if => Puppet.features.posix? do
+      it "should allow source_permissions to be overridden" do
+        file = generate_file_resource(:source_permissions => :use)
 
-      expect(file[:source_permissions]).to eq(:use)
-    end
+        expect(file[:source_permissions]).to eq(:use)
+      end
 
-    describe "on POSIX", :if => Puppet.features.posix? do
       it "should always set the owner to the current UID" do
         Process.expects(:uid).returns 51
 

data/spec/unit/configurer_spec.rb

@@ -369,12 +369,34 @@ 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 "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)
 
-      expect($env_module_directories).to eq(nil)
+      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
@@ -544,17 +566,42 @@ describe Puppet::Configurer do
     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
@@ -563,18 +610,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
@@ -583,6 +735,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"
@@ -598,17 +757,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
@@ -620,72 +783,141 @@ 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
+
+      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
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      expect(described_class).not_to be_should_pluginsync
     end
   end
 end