puppet 7.4.0-x64-mingw32 → 7.8.0-x64-mingw32

data/spec/integration/indirector/direct_file_server_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'matchers/include'
 
 require 'puppet/indirector/file_content/file'
 require 'puppet/indirector/file_metadata/file'
@@ -30,7 +29,6 @@ end
 
 describe Puppet::Indirector::DirectFileServer, " when interacting with FileServing::Fileset and the model" do
   include PuppetSpec::Files
-  include Matchers::Include
 
   matcher :file_with_content do |name, content|
     match do |actual|
@@ -52,7 +50,7 @@ describe Puppet::Indirector::DirectFileServer, " when interacting with FileServi
     terminus = Puppet::Indirector::FileContent::File.new
     request = terminus.indirection.request(:search, Puppet::Util.path_to_uri(path).to_s, nil, :recurse => true)
 
-    expect(terminus.search(request)).to include_in_any_order(
+    expect(terminus.search(request)).to contain_exactly(
       file_with_content(File.join(path, "one"), "one content"),
       file_with_content(File.join(path, "two"), "two content"),
       directory_named(path))

data/spec/integration/parser/collection_spec.rb

@@ -235,6 +235,16 @@ describe 'collectors' do
         MANIFEST
       end
 
+      it "splats attributes from a hash" do
+        expect_the_message_to_be(["overridden message"], <<-MANIFEST)
+          @notify { "testing": message => "original message" }
+
+          Notify <| |> {
+            * => { message => "overridden message" }
+          }
+        MANIFEST
+      end
+
       it "collects with override when inside a class (#10963)" do
         expect_the_message_to_be(["overridden message"], <<-MANIFEST)
           @notify { "testing": message => "original message" }

data/spec/integration/type/file_spec.rb

@@ -895,7 +895,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
             # Change the source file.
             File.open(checksum_file, "wb") { |f| f.write "some content" }
-            FileUtils.touch target_file, :mtime => Time.now - 20
+            FileUtils.touch target_file, mtime: Time.now - 20
 
             # The 2nd time should update the resource.
             second_catalog.add_resource Puppet::Type.send(:newfile, @options)
@@ -1399,7 +1399,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
         it "should fetch if no header specified" do
           File.open(httppath, "wb") { |f| f.puts "Content originally on disk\n" }
           # make sure the mtime is not "right now", lest we get a race
-          FileUtils.touch httppath, :mtime => Time.parse("Sun, 22 Mar 2015 22:57:43 GMT")
+          FileUtils.touch httppath, mtime: Time.parse("Sun, 22 Mar 2015 22:57:43 GMT")
           catalog.add_resource resource
           catalog.apply
           expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
@@ -1409,7 +1409,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
         it "should fetch if mtime is older on disk" do
           File.open(httppath, "wb") { |f| f.puts "Content originally on disk\n" }
           # fixture has Last-Modified: Sun, 22 Mar 2015 22:25:34 GMT
-          FileUtils.touch httppath, :mtime => Time.parse("Sun, 22 Mar 2015 22:22:34 GMT")
+          FileUtils.touch httppath, mtime: Time.parse("Sun, 22 Mar 2015 22:22:34 GMT")
           catalog.add_resource resource
           catalog.apply
           expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
@@ -1455,7 +1455,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
         it "should not update if content on disk is up-to-date" do
           File.open(httppath, "wb") { |f| f.puts "Content via HTTP\n" }
           disk_mtime = Time.parse("Sun, 22 Mar 2015 22:22:34 GMT")
-          FileUtils.touch httppath, :mtime => disk_mtime
+          FileUtils.touch httppath, mtime: disk_mtime
           catalog.add_resource resource
           catalog.apply
           expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
@@ -2002,7 +2002,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
     it "should not update mtime on an old directory" do
       disk_mtime = Time.parse("Sun, 22 Mar 2015 22:22:34 GMT")
       FileUtils.mkdir_p path
-      FileUtils.touch path, :mtime => disk_mtime
+      FileUtils.touch path, mtime: disk_mtime
       status = catalog.apply.report.resource_statuses["File[#{path}]"]
       expect(status).to be_nil
       expect(Puppet::FileSystem).to be_directory(path)

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

@@ -55,6 +55,24 @@ describe Puppet::Util::Windows::ADSI::User,
       end
     end
   end
+
+  describe '.current_user_name_with_format' do
+    context 'when desired format is NameSamCompatible' do
+      it 'should get the same user name as the current_user_name method but fully qualified' do
+        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
+        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
+
+        expect(fully_qualified_user_name).to match(/^.+\\#{user_name}$/)
+      end
+
+      it 'should have the same SID as with the current_user_name method' do
+        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
+        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
+
+        expect(Puppet::Util::Windows::SID.name_to_sid(user_name)).to eq(Puppet::Util::Windows::SID.name_to_sid(fully_qualified_user_name))
+      end
+    end
+  end
 end
 
 describe Puppet::Util::Windows::ADSI::Group,

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

@@ -7,6 +7,7 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet::Util::Platform.wi
   let (:system_bytes) { [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0] }
   let (:null_sid_bytes) { [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
   let (:administrator_bytes) { [1, 2, 0, 0, 0, 0, 0, 5, 32, 0, 0, 0, 32, 2, 0, 0] }
+  let (:all_application_packages_bytes) { [1, 2, 0, 0, 0, 0, 0, 15, 2, 0, 0, 0, 1, 0, 0, 0] }
   let (:computer_sid) { Puppet::Util::Windows::SID.name_to_principal(Puppet::Util::Windows::ADSI.computer_name) }
   # BUILTIN is localized on German Windows, but not French
   # looking this up like this dilutes the values of the tests as we're comparing two mechanisms
@@ -121,6 +122,26 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet::Util::Platform.wi
       expect(principal.to_s).to eq(builtin_localized)
     end
 
+    it "should always sanitize the account name first" do
+      expect(Puppet::Util::Windows::SID::Principal).to receive(:sanitize_account_name).with('NT AUTHORITY\\SYSTEM').and_call_original
+      Puppet::Util::Windows::SID::Principal.lookup_account_name('NT AUTHORITY\\SYSTEM')
+    end
+
+    it "should be able to create an instance from an account name prefixed by APPLICATION PACKAGE AUTHORITY" do
+      principal = Puppet::Util::Windows::SID::Principal.lookup_account_name('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
+      expect(principal.account).to eq('ALL APPLICATION PACKAGES')
+      expect(principal.sid_bytes).to eq(all_application_packages_bytes)
+      expect(principal.sid).to eq('S-1-15-2-1')
+      expect(principal.domain).to eq('APPLICATION PACKAGE AUTHORITY')
+      expect(principal.domain_account).to eq('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
+      expect(principal.account_type).to eq(:SidTypeWellKnownGroup)
+      expect(principal.to_s).to eq('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
+    end
+
+    it "should fail without proper account name sanitization when it is prefixed by APPLICATION PACKAGE AUTHORITY" do
+      given_account_name = 'APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES'
+      expect { Puppet::Util::Windows::SID::Principal.lookup_account_name(nil, false, given_account_name) }.to raise_error(Puppet::Util::Windows::Error, /No mapping between account names and security IDs was done./)
+    end
   end
 
   describe ".lookup_account_sid" do

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

@@ -263,6 +263,12 @@ describe Puppet::Util::Windows::Registry do
           type: Win32::Registry::REG_EXPAND_SZ,
           value: "\0\0\0reg expand string",
           expected_value: ""
+        },
+        {
+          name: 'REG_EXPAND_SZ_2',
+          type: Win32::Registry::REG_EXPAND_SZ,
+          value: "1\x002\x003\x004\x00\x00\x00\x90\xD8UoY".force_encoding("UTF-16LE"),
+          expected_value: "1234"
         }
       ].each do |pair|
         it 'reads up to the first wide null' do

data/spec/lib/puppet/test_ca.rb

@@ -30,7 +30,7 @@ module Puppet
     end
 
     def create_request(name)
-      key = OpenSSL::PKey::RSA.new(1024)
+      key = OpenSSL::PKey::RSA.new(2048)
       csr = OpenSSL::X509::Request.new
       csr.public_key = key.public_key
       csr.subject = OpenSSL::X509::Name.new([["CN", name]])
@@ -127,7 +127,7 @@ module Puppet
       key = if opts[:key_type] == :ec
               key = OpenSSL::PKey::EC.generate('prime256v1')
             else
-              key = OpenSSL::PKey::RSA.new(1024)
+              key = OpenSSL::PKey::RSA.new(2048)
             end
       cert = OpenSSL::X509::Certificate.new
       cert.public_key = if key.is_a?(OpenSSL::PKey::EC)

data/spec/lib/puppet_spec/files.rb

@@ -9,7 +9,7 @@ module PuppetSpec::Files
     $global_tempfiles ||= []
     while path = $global_tempfiles.pop do
       begin
-        FileUtils.rm_rf path, :secure => true
+        FileUtils.rm_rf path, secure: true
       rescue Errno::ENOENT
         # nothing to do
       end

data/spec/shared_contexts/provider.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.shared_context('provider specificity') do
+  around do |example|
+    old_defaults = described_class.instance_variable_get(:@defaults)
+    old_notdefaults = described_class.instance_variable_get(:@notdefaults)
+    begin
+      described_class.instance_variable_set(:@defaults, [])
+      described_class.instance_variable_set(:@notdefaults, [])
+      example.run
+    ensure
+      described_class.instance_variable_set(:@defaults, old_defaults)
+      described_class.instance_variable_set(:@notdefaults, old_notdefaults)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -162,10 +162,20 @@ RSpec.configure do |config|
   PUPPET_FACTER_2_GCE_URL = %r{^http://metadata/computeMetadata/v1(beta1)?}.freeze
   PUPPET_FACTER_3_GCE_URL = "http://metadata.google.internal/computeMetadata/v1/?recursive=true&alt=json".freeze
 
+  # Facter azure metadata endpoint
+  PUPPET_FACTER_AZ_URL = "http://169.254.169.254/metadata/instance?api-version=2020-09-01"
+
+  # Facter EC2 endpoint
+  PUPPET_FACTER_EC2_METADATA = 'http://169.254.169.254/latest/meta-data/'
+  PUPPET_FACTER_EC2_USERDATA = 'http://169.254.169.254/latest/user-data/'
+
   config.around :each do |example|
-    # Ignore requests from Facter GCE fact in Travis
+    # Ignore requests from Facter to external services
     stub_request(:get, PUPPET_FACTER_2_GCE_URL)
     stub_request(:get, PUPPET_FACTER_3_GCE_URL)
+    stub_request(:get, PUPPET_FACTER_AZ_URL)
+    stub_request(:get, PUPPET_FACTER_EC2_METADATA)
+    stub_request(:get, PUPPET_FACTER_EC2_USERDATA)
 
     # Enable VCR if the example is tagged with `:vcr` metadata.
     if example.metadata[:vcr]

data/spec/unit/application/agent_spec.rb

@@ -546,11 +546,16 @@ describe Puppet::Application::Agent do
         @puppetd.options[:digest] = :MD5
       end
 
+      def expected_fingerprint(name, x509)
+        digest = OpenSSL::Digest.new(name).hexdigest(x509.to_der)
+        digest.scan(/../).join(':').upcase
+      end
+
       it "should fingerprint the certificate if it exists" do
         cert = cert_fixture('signed.pem')
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_client_cert).and_return(cert)
 
-        expect(@puppetd).to receive(:puts).with('(MD5) E2:BA:9A:EF:20:A8:7D:10:8D:82:9A:61:5D:FD:5B:33')
+        expect(@puppetd).to receive(:puts).with("(MD5) #{expected_fingerprint('md5', cert)}")
 
         @puppetd.fingerprint
       end
@@ -560,7 +565,7 @@ describe Puppet::Application::Agent do
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_client_cert).and_return(nil)
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_request).and_return(request)
 
-        expect(@puppetd).to receive(:puts).with('(MD5) B8:4C:FB:31:AE:17:86:E3:AD:53:97:CA:F6:3C:4A:CB')
+        expect(@puppetd).to receive(:puts).with("(MD5) #{expected_fingerprint('md5', request)}")
 
         @puppetd.fingerprint
       end

data/spec/unit/application/facts_spec.rb

@@ -3,7 +3,7 @@ require 'puppet/application/facts'
 
 describe Puppet::Application::Facts do
   let(:app) { Puppet::Application[:facts] }
-  let(:values) { {"filesystems" => "apfs,autofs,devfs", "macaddress" => "64:52:11:22:03:25"} }
+  let(:values) { {"filesystems" => "apfs,autofs,devfs", "macaddress" => "64:52:11:22:03:2e"} }
 
   before :each do
     Puppet::Node::Facts.indirection.terminus_class = :memory
@@ -21,7 +21,7 @@ describe Puppet::Application::Facts do
       name: whatever
       values:
         filesystems: apfs,autofs,devfs
-        macaddress: "64:52:11:22:03:25"
+        macaddress: "64:52:11:22:03:2e"
     END
 
     expect {
@@ -42,7 +42,7 @@ describe Puppet::Application::Facts do
       name: #{Puppet[:certname]}
       values:
         filesystems: apfs,autofs,devfs
-        macaddress: "64:52:11:22:03:25"
+        macaddress: "64:52:11:22:03:2e"
     END
 
     expect {
@@ -55,7 +55,7 @@ describe Puppet::Application::Facts do
     let(:expected) { <<~END }
       {
         "filesystems": "apfs,autofs,devfs",
-        "macaddress": "64:52:11:22:03:25"
+        "macaddress": "64:52:11:22:03:2e"
       }
     END
 
@@ -119,7 +119,7 @@ describe Puppet::Application::Facts do
     let(:expected) { <<~END }
       ---
       filesystems: apfs,autofs,devfs
-      macaddress: 64:52:11:22:03:25
+      macaddress: 64:52:11:22:03:2e
     END
 
     before :each do

data/spec/unit/application/ssl_spec.rb

@@ -432,4 +432,27 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       expects_command_to_pass
     end
   end
+
+  context 'when showing' do
+    before do
+      ssl.command_line.args << 'show'
+      File.write(Puppet[:hostcert], @host[:cert].to_pem)
+    end
+
+    it 'reports if the key is missing' do
+      File.delete(Puppet[:hostprivkey])
+
+      expects_command_to_fail(/The private key is missing from/)
+    end
+
+    it 'reports if the cert is missing' do
+      File.delete(Puppet[:hostcert])
+
+      expects_command_to_fail(/The client certificate is missing from/)
+    end
+
+    it 'prints certificate information' do
+      expects_command_to_pass(@host[:cert].to_text)
+    end
+  end
 end

data/spec/unit/configurer/downloader_spec.rb

@@ -81,6 +81,12 @@ describe Puppet::Configurer::Downloader do
       expect(file[:source_permissions]).to eq(:ignore)
     end
 
+    it "should ignore the max file limit" do
+      file = generate_file_resource
+
+      expect(file[:max_files]).to eq(-1)
+    end
+
     describe "on POSIX", :if => Puppet.features.posix? do
       it "should allow source_permissions to be overridden" do
         file = generate_file_resource(:source_permissions => :use)

data/spec/unit/configurer_spec.rb

@@ -1075,6 +1075,29 @@ describe Puppet::Configurer do
       }.to raise_error(Puppet::Error, /Could not select a functional puppet server from server_list: 'myserver:123,someotherservername'/)
     end
 
+    it "should warn when servers in 'server_list' are unreachable" do
+      Puppet.settings[:server_list] = "mybadserver1:123,mybadserver2:123,mygoodserver"
+      Puppet[:usecacheonfailure] = false
+
+      stub_request(:get, 'https://mybadserver1:123/status/v1/simple/server').and_raise(Puppet::HTTP::HTTPError)
+      stub_request(:get, 'https://mybadserver2:123/status/v1/simple/server').and_raise(Puppet::HTTP::HTTPError)
+      stub_request(:get, 'https://mygoodserver:8140/status/v1/simple/server').to_return(status: 200)
+
+      expect(Puppet).to receive(:warning).with(/^Unable to connect to server from server_list setting:.*Trying with next server from server_list.$/).twice
+      configurer.run
+    end
+
+    it "should warn when servers in 'server_list' respond with error" do
+      Puppet.settings[:server_list] = "mybadserver:123,someotherservername"
+      Puppet[:usecacheonfailure] = false
+
+      stub_request(:get, 'https://mybadserver:123/status/v1/simple/server').to_return(status: 400)
+      stub_request(:get, 'https://someotherservername:8140/status/v1/simple/server').to_return(status: 200)
+
+      expect(Puppet).to receive(:warning).with(/^Puppet server mybadserver:123 is unavailable: 400  Trying with next server from server_list.$/)
+      configurer.run
+    end
+
     it "should not error when usecacheonfailure is true and no servers in 'server_list' are reachable" do
       Puppet.settings[:server_list] = "myserver:123,someotherservername"
       Puppet[:usecacheonfailure] = true

data/spec/unit/environments_spec.rb

@@ -1,13 +1,8 @@
 require 'spec_helper'
 require 'puppet/environments'
 require 'puppet/file_system'
-require 'matchers/include'
-require 'matchers/include_in_order'
 
-module PuppetEnvironments
 describe Puppet::Environments do
-  include Matchers::Include
-
   FS = Puppet::FileSystem
 
   before(:each) do
@@ -49,7 +44,7 @@ describe Puppet::Environments do
       loader_from(:filesystem => [directory_tree, global_path_1, global_path_2],
                   :directory => directory_tree.children.first,
                   :modulepath => [global_path_1_location, global_path_2_location]) do |loader|
-        expect(loader.list).to include_in_any_order(
+        expect(loader.list).to contain_exactly(
           environment(:an_environment).
             with_manifest("#{FS.path_string(directory_tree)}/envdir/an_environment/manifests").
             with_modulepath(["#{FS.path_string(directory_tree)}/envdir/an_environment/modules",
@@ -87,7 +82,7 @@ describe Puppet::Environments do
 
       loader_from(:filesystem => [envdir],
                   :directory => envdir) do |loader|
-        expect(loader.list).to include_in_any_order(environment(:env1), environment(:env2))
+        expect(loader.list).to contain_exactly(environment(:env1), environment(:env2))
       end
     end
 
@@ -406,33 +401,29 @@ config_version=$vardir/random/scripts
           ]),
         ])
 
-        FS.overlay(original_envdir) do
-          dir_loader = Puppet::Environments::Directories.new(original_envdir, [])
-          loader = Puppet::Environments::Cached.new(dir_loader)
-          Puppet.override(:environments => loader) do
-            original_env = loader.get("env3") # force the environment.conf to be read
-
-            changed_envdir = FS::MemoryFile.a_directory(base_dir, [
-              FS::MemoryFile.a_directory("env3", [
-                FS::MemoryFile.a_regular_file_containing("environment.conf", <<-EOF)
-                  manifest=/manifest_changed
-                  modulepath=/modules_changed
-                  environment_timeout=0
-                EOF
-              ]),
-            ])
+        cached_loader_from(:filesystem => [original_envdir], :directory => original_envdir) do |loader|
+          original_env = loader.get("env3") # force the environment.conf to be read
 
-            FS.overlay(changed_envdir) do
-              changed_env = loader.get("env3")
+          changed_envdir = FS::MemoryFile.a_directory(base_dir, [
+            FS::MemoryFile.a_directory("env3", [
+              FS::MemoryFile.a_regular_file_containing("environment.conf", <<-EOF)
+                manifest=/manifest_changed
+                modulepath=/modules_changed
+                environment_timeout=0
+              EOF
+            ]),
+          ])
 
-              expect(original_env).to environment(:env3).
-                with_manifest(File.expand_path("/manifest_orig")).
-                with_full_modulepath([File.expand_path("/modules_orig")])
+          FS.overlay(changed_envdir) do
+            changed_env = loader.get("env3")
 
-              expect(changed_env).to environment(:env3).
-                with_manifest(File.expand_path("/manifest_changed")).
-                with_full_modulepath([File.expand_path("/modules_changed")])
-            end
+            expect(original_env).to environment(:env3).
+              with_manifest(File.expand_path("/manifest_orig")).
+              with_full_modulepath([File.expand_path("/modules_orig")])
+
+            expect(changed_env).to environment(:env3).
+              with_manifest(File.expand_path("/manifest_changed")).
+              with_full_modulepath([File.expand_path("/modules_changed")])
           end
         end
       end
@@ -558,24 +549,49 @@ config_version=$vardir/random/scripts
 
   describe "cached loaders" do
     it "lists environments" do
-      loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-        expect(Puppet::Environments::Cached.new(loader).list).to include_in_any_order(
+      cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        expect(loader.list).to contain_exactly(
           environment(:an_environment),
           environment(:another_environment),
           environment(:symlinked_environment))
       end
     end
 
+    it "returns the same cached environment object for list and get methods" do
+      cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        env = loader.list.find { |e| e.name == :an_environment }
+
+        expect(env).to equal(loader.get(:an_environment)) # same object
+      end
+    end
+
+    it "returns the same cached environment object for multiple list calls" do
+      cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        expect(loader.list.first).to equal(loader.list.first) # same object
+      end
+    end
+
+    it "expires environments and returns a new environment object with the same value" do
+      Puppet[:environment_timeout] = "0"
+
+      cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        a = loader.list.first
+        b = loader.list.first
+        expect(a).to eq(b)        # same value
+        expect(a).to_not equal(b) # not same object
+      end
+    end
+
     it "has search_paths" do
-      loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-        expect(Puppet::Environments::Cached.new(loader).search_paths).to eq(["file://#{directory_tree.children.first}"])
+      cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        expect(loader.search_paths).to eq(["file://#{directory_tree.children.first}"])
       end
     end
 
     context "#get" do
       it "gets an environment" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-          expect(Puppet::Environments::Cached.new(loader).get(:an_environment)).to environment(:an_environment)
+        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+          expect(loader.get(:an_environment)).to environment(:an_environment)
         end
       end
 
@@ -592,16 +608,16 @@ config_version=$vardir/random/scripts
       end
 
       it "returns nil if env not found" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-          expect(Puppet::Environments::Cached.new(loader).get(:doesnotexist)).to be_nil
+        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+          expect(loader.get(:doesnotexist)).to be_nil
         end
       end
     end
 
     context "#get!" do
       it "gets an environment" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-          expect(Puppet::Environments::Cached.new(loader).get!(:an_environment)).to environment(:an_environment)
+        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+          expect(loader.get!(:an_environment)).to environment(:an_environment)
         end
       end
 
@@ -618,14 +634,41 @@ config_version=$vardir/random/scripts
       end
 
       it "raises error if environment is not found" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
           expect do
-            Puppet::Environments::Cached.new(loader).get!(:doesnotexist)
+            loader.get!(:doesnotexist)
           end.to raise_error(Puppet::Environments::EnvironmentNotFound)
         end
       end
     end
 
+    context "#get_conf" do
+      it "loads environment.conf" do
+        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+          expect(loader.get_conf(:an_environment)).to match_environment_conf(:an_environment).
+            with_env_path(directory_tree.children.first).
+            with_global_module_path([])
+        end
+      end
+
+      it "always reloads environment.conf" do
+        env = Puppet::Node::Environment.create(:cached, [])
+        mocked_loader = double('loader')
+        expect(mocked_loader).to receive(:get_conf).with(:cached).and_return(Puppet::Settings::EnvironmentConf.static_for(env, 20)).twice
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+
+        cached.get_conf(:cached)
+        cached.get_conf(:cached)
+      end
+
+      it "returns nil if environment is not found" do
+        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+          expect(loader.get_conf(:doesnotexist)).to be_nil
+        end
+      end
+    end
+
     context "expiration policies" do
       let(:service) { ReplayExpirationService.new }
 
@@ -647,8 +690,6 @@ config_version=$vardir/random/scripts
       end
 
       it "evicts an expired environment" do
-        service = ReplayExpirationService.new
-
         expect(service).to receive(:expired?).and_return(true)
 
         with_environment_loaded(service) do |cached|
@@ -700,13 +741,15 @@ config_version=$vardir/random/scripts
         expect(service.created_envs).to eq([:an_environment, :an_environment])
         expect(service.evicted_envs).to eq([:an_environment])
       end
-    end
 
-    it "gets an environment.conf" do
-      loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-        expect(Puppet::Environments::Cached.new(loader).get_conf(:an_environment)).to match_environment_conf(:an_environment).
-          with_env_path(directory_tree.children.first).
-          with_global_module_path([])
+      it "evicts expired environments when listing" do
+        expect(service).to receive(:expired?).with(:an_environment).and_return(true)
+
+        with_environment_loaded(service) do |cached|
+          cached.list
+        end
+
+        expect(service.evicted_envs).to eq([:an_environment])
       end
     end
 
@@ -724,6 +767,30 @@ config_version=$vardir/random/scripts
 
     context '#clear_all' do
       let(:service) { ReplayExpirationService.new }
+      let(:envdir) { File.expand_path("envdir") }
+      let(:default_dir) { File.join(envdir, "cached_env", "modules") }
+      let(:expected_dir) { File.join(envdir, "cached_env", "site") }
+
+      let(:base_dir) do
+        FS::MemoryFile.a_directory(envdir, [
+          FS::MemoryFile.a_directory("cached_env", [
+            FS::MemoryFile.a_missing_file("environment.conf")
+          ])
+        ])
+      end
+
+      let(:updated_dir) do
+        FS::MemoryFile.a_directory(envdir, [
+          FS::MemoryFile.a_directory("cached_env", [
+            FS::MemoryFile.a_directory("site"),
+            FS::MemoryFile.a_missing_directory("modules"),
+            FS::MemoryFile.a_regular_file_containing("environment.conf", <<-EOF)
+              modulepath=site
+              environment_timeout=unlimited
+            EOF
+          ])
+        ])
+      end
 
       it 'evicts all environments' do
         with_environment_loaded(service) do |cached|
@@ -735,48 +802,44 @@ config_version=$vardir/random/scripts
         end
       end
 
-      it 'clears cached environment settings' do
-        base_dir = File.expand_path("envdir")
-        original_envdir = FS::MemoryFile.a_directory(base_dir, [
-          FS::MemoryFile.a_directory("env3", [
-            FS::MemoryFile.a_regular_file_containing("environment.conf", <<-EOF)
-              manifest=/manifest_orig
-              modulepath=/modules_orig
-              environment_timeout=60
-            EOF
-          ]),
-        ])
+      it "recomputes modulepath if 'get' is called before 'clear_all'" do
+        cached_loader_from(:filesystem => [base_dir], :directory => base_dir) do |loader|
+          loader.get(:cached_env)
 
-        FS.overlay(original_envdir) do
-          dir_loader = Puppet::Environments::Directories.new(original_envdir, [])
-          loader = Puppet::Environments::Cached.new(dir_loader)
-          Puppet.override(:environments => loader) do
-            original_env = loader.get("env3") # force the environment.conf to be read
-
-            changed_envdir = FS::MemoryFile.a_directory(base_dir, [
-              FS::MemoryFile.a_directory("env3", [
-                FS::MemoryFile.a_regular_file_containing("environment.conf", <<-EOF)
-                  manifest=/manifest_changed
-                  modulepath=/modules_changed
-                  environment_timeout=60
-                EOF
-              ]),
-            ])
+          expect(Puppet.settings.value(:modulepath, :cached_env)).to eq(default_dir)
 
-            #Clear all cached environments
+          FS.overlay(updated_dir) do
             loader.clear_all
 
-            FS.overlay(changed_envdir) do
-              changed_env = loader.get("env3")
+            expect(loader.get(:cached_env).modulepath).to contain_exactly(expected_dir)
+          end
+        end
+      end
+
+      it "recomputes modulepath if 'list' is called before 'clear_all'"  do
+        cached_loader_from(:filesystem => [base_dir], :directory => base_dir) do |loader|
+          loader.list
 
-              expect(original_env).to environment(:env3).
-                with_manifest(File.expand_path("/manifest_orig")).
-                with_full_modulepath([File.expand_path("/modules_orig")])
+          expect(Puppet.settings.value(:modulepath, :cached_env)).to eq(default_dir)
 
-              expect(changed_env).to environment(:env3).
-                with_manifest(File.expand_path("/manifest_changed")).
-                with_full_modulepath([File.expand_path("/modules_changed")])
-            end
+          FS.overlay(updated_dir) do
+            loader.clear_all
+
+            expect(loader.get(:cached_env).modulepath).to contain_exactly(expected_dir)
+          end
+        end
+      end
+
+      it "recomputes modulepath if 'get_conf' is called before 'clear_all'" do
+        cached_loader_from(:filesystem => [base_dir], :directory => base_dir) do |loader|
+          loader.get_conf(:cached_env)
+
+          expect(Puppet.settings.value(:modulepath, :cached_env)).to eq(default_dir)
+
+          FS.overlay(updated_dir) do
+            loader.clear_all
+
+            expect(loader.get(:cached_env).modulepath).to contain_exactly(expected_dir)
           end
         end
       end
@@ -862,6 +925,20 @@ config_version=$vardir/random/scripts
     end
   end
 
+  def cached_loader_from(options, &block)
+    FS.overlay(*options[:filesystem]) do
+      environments = Puppet::Environments::Cached.new(
+        Puppet::Environments::Directories.new(
+          options[:directory],
+          options[:modulepath] || []
+        )
+      )
+      Puppet.override(:environments => environments) do
+        yield environments
+      end
+    end
+  end
+
   def loader_from(options, &block)
     FS.overlay(*options[:filesystem]) do
       environments = Puppet::Environments::Directories.new(
@@ -914,4 +991,3 @@ config_version=$vardir/random/scripts
     end
   end
 end
-end