puppet 5.3.4 → 6.29.0

data/spec/unit/environments_spec.rb

@@ -1,32 +1,44 @@
 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
 
+  module FsRemove
+    def remove
+      @properties[:directory?] = false
+      @properties[:exist?] = false
+      @properties[:executable?] = false
+    end
+  end
+
   before(:each) do
     Puppet.settings.initialize_global_settings
     Puppet[:environment_timeout] = "unlimited"
+    Puppet[:versioned_environment_dirs] = true
   end
 
   let(:directory_tree) do
-    FS::MemoryFile.a_directory(File.expand_path("envdir"), [
-      FS::MemoryFile.a_regular_file_containing("ignored_file", ''),
-      FS::MemoryFile.a_directory("an_environment", [
-        FS::MemoryFile.a_missing_file("environment.conf"),
+    FS::MemoryFile.a_directory(File.expand_path("top_level_dir"), [
+      FS::MemoryFile.a_directory("envdir", [
+        FS::MemoryFile.a_regular_file_containing("ignored_file", ''),
+        FS::MemoryFile.a_directory("an_environment", [
+          FS::MemoryFile.a_missing_file("environment.conf"),
+          FS::MemoryFile.a_directory("modules"),
+          FS::MemoryFile.a_directory("manifests"),
+        ]),
+        FS::MemoryFile.a_directory("another_environment", [
+          FS::MemoryFile.a_missing_file("environment.conf"),
+        ]),
+        FS::MemoryFile.a_missing_file("doesnotexist"),
+        FS::MemoryFile.a_symlink("symlinked_environment", File.expand_path(File.join("top_level_dir", "versioned_env")))]),
+      FS::MemoryFile.a_directory("versioned_env", [
+        FS::MemoryFile.a_regular_file_containing("environment.conf", ''),
         FS::MemoryFile.a_directory("modules"),
         FS::MemoryFile.a_directory("manifests"),
       ]),
-      FS::MemoryFile.a_directory("another_environment", [
-        FS::MemoryFile.a_missing_file("environment.conf"),
-      ]),
-      FS::MemoryFile.a_missing_file("doesnotexist"),
+      FS::MemoryFile.a_missing_file("missing")
     ])
   end
 
@@ -38,22 +50,27 @@ describe Puppet::Environments do
       global_path_2 = FS::MemoryFile.a_directory(global_path_2_location)
 
       loader_from(:filesystem => [directory_tree, global_path_1, global_path_2],
-                  :directory => directory_tree,
+                  :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)}/an_environment/manifests").
-            with_modulepath(["#{FS.path_string(directory_tree)}/an_environment/modules",
+            with_manifest("#{FS.path_string(directory_tree)}/envdir/an_environment/manifests").
+            with_modulepath(["#{FS.path_string(directory_tree)}/envdir/an_environment/modules",
                              global_path_1_location,
                              global_path_2_location]),
-          environment(:another_environment))
+          environment(:another_environment),
+          environment(:symlinked_environment).
+            with_manifest("#{FS.path_string(directory_tree)}/versioned_env/manifests").
+            with_modulepath(["#{FS.path_string(directory_tree)}/versioned_env/modules",
+                             global_path_1_location,
+                             global_path_2_location]))
       end
     end
 
     it "has search_paths" do
       loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
-        expect(loader.search_paths).to eq(["file://#{directory_tree}"])
+                  :directory => directory_tree.children.first) do |loader|
+        expect(loader.search_paths).to eq(["file://#{directory_tree.children.first}"])
       end
     end
 
@@ -73,20 +90,42 @@ 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
+
+    it "proceeds with non-existant env dir" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.last) do |loader|
+        expect(loader.list).to eq([])
       end
     end
 
     it "gets a particular environment" do
       loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
+                  :directory => directory_tree.children.first) do |loader|
         expect(loader.get("an_environment")).to environment(:an_environment)
       end
     end
 
+    it "gets a symlinked environment" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.first) do |loader|
+        expect(loader.get("symlinked_environment")).to environment(:symlinked_environment)
+      end
+    end
+
+    it "ignores symlinked environments when `:versioned_environment_dirs` is false" do
+      Puppet[:versioned_environment_dirs] = false
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.first) do |loader|
+        expect(loader.get("symlinked_environment")).to be_nil
+      end
+    end
+
     it "raises error when environment not found" do
       loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
+                  :directory => directory_tree.children.first) do |loader|
         expect do
           loader.get!("doesnotexist")
         end.to raise_error(Puppet::Environments::EnvironmentNotFound)
@@ -95,11 +134,19 @@ describe Puppet::Environments do
 
     it "returns nil if an environment can't be found" do
       loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
+                  :directory => directory_tree.children.first) do |loader|
         expect(loader.get("doesnotexist")).to be_nil
       end
     end
 
+    it "implements guard and unguard" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.first) do |loader|
+        expect(loader.guard('env1')).to be_nil
+        expect(loader.unguard('env1')).to be_nil
+      end
+    end
+
     context "with an environment.conf" do
       let(:envdir) do
         FS::MemoryFile.a_directory(File.expand_path("envdir"), [
@@ -265,6 +312,46 @@ config_version=relative/script
         end
       end
 
+      it "interprets glob modulepaths from the environment's directory" do
+        allow(Dir).to receive(:glob).with(File.join(envdir, 'env1', 'other', '*', 'modules')).and_return([
+          File.join(envdir, 'env1', 'other', 'foo', 'modules'),
+          File.join(envdir, 'env1', 'other', 'bar', 'modules')
+        ])
+        content = <<-EOF
+manifest=relative/manifest
+modulepath=relative/modules#{File::PATH_SEPARATOR}other/*/modules
+config_version=relative/script
+        EOF
+
+        envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+          FS::MemoryFile.a_directory("env1", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", content),
+            FS::MemoryFile.a_missing_file("modules"),
+            FS::MemoryFile.a_directory('relative', [
+              FS::MemoryFile.a_directory('modules'),
+            ]),
+            FS::MemoryFile.a_directory('other', [
+              FS::MemoryFile.a_directory('foo', [
+                FS::MemoryFile.a_directory('modules'),
+              ]),
+              FS::MemoryFile.a_directory('bar', [
+                FS::MemoryFile.a_directory('modules'),
+              ]),
+            ]),
+          ]),
+        ])
+
+        loader_from(:filesystem => [envdir],
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(File.join(envdir, 'env1', 'relative', 'manifest')).
+            with_modulepath([File.join(envdir, 'env1', 'relative', 'modules'),
+                             File.join(envdir, 'env1', 'other', 'foo', 'modules'),
+                             File.join(envdir, 'env1', 'other', 'bar', 'modules')]).
+            with_config_version(File.join(envdir, 'env1', 'relative', 'script'))
+        end
+      end
+
       it "interpolates other setting values correctly" do
         modulepath = [
           File.expand_path('/some/absolute'),
@@ -330,52 +417,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
-              ]),
-            ])
-
-            FS.overlay(changed_envdir) do
-              changed_env = loader.get("env3")
+        cached_loader_from(:filesystem => [original_envdir], :directory => original_envdir) do |loader|
+          original_env = loader.get("env3") # force the environment.conf to be read
 
-              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
-      end
+          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
+            ]),
+          ])
 
-      context "custom cache expiration service" do
-        it "consults the custom service to expire the cache" do
-          loader_from(:filesystem => [directory_tree],
-                      :directory => directory_tree) do |loader|
-            service = ReplayExpirationService.new([true])
-            using_expiration_service(service) do
+          FS.overlay(changed_envdir) do
+            changed_env = loader.get("env3")
 
-              cached = Puppet::Environments::Cached.new(loader)
-              cached.get(:an_environment)
-              cached.get(:an_environment)
+            expect(original_env).to environment(:env3).
+              with_manifest(File.expand_path("/manifest_orig")).
+              with_full_modulepath([File.expand_path("/modules_orig")])
 
-              expect(service.created_envs).to include(:an_environment)
-              expect(service.expired_envs).to include(:an_environment)
-              expect(service.evicted_envs).to include(:an_environment)
-            end
+            expect(changed_env).to environment(:env3).
+              with_manifest(File.expand_path("/manifest_changed")).
+              with_full_modulepath([File.expand_path("/modules_changed")])
           end
         end
       end
@@ -421,6 +485,13 @@ config_version=$vardir/random/scripts
       expect(loader.get_conf(:doesnotexist)).to be_nil
     end
 
+    it "gets the conf environment_timeout if one is specified" do
+      Puppet[:environment_timeout] = 8675
+      conf = loader.get_conf(:static1)
+
+      expect(conf.environment_timeout).to eq(8675)
+    end
+
     context "that are private" do
       let(:private_env) { Puppet::Node::Environment.create(:private, []) }
       let(:loader) { Puppet::Environments::StaticPrivate.new(private_env) }
@@ -494,31 +565,57 @@ config_version=$vardir/random/scripts
 
   describe "cached loaders" do
     it "lists environments" do
-      loader_from(:filesystem => [directory_tree], :directory => directory_tree) 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(: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) do |loader|
-        expect(Puppet::Environments::Cached.new(loader).search_paths).to eq(["file://#{directory_tree}"])
+      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) 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
 
       it "does not reload the environment if it isn't expired" do
         env = Puppet::Node::Environment.create(:cached, [])
-        mocked_loader = mock('loader')
-        mocked_loader.expects(:get).with(:cached).returns(env).once
-        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
+        mocked_loader = double('loader')
+        expect(mocked_loader).to receive(:get).with(:cached).and_return(env).once
+        expect(mocked_loader).to receive(:get_conf).with(:cached).and_return(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
 
         cached = Puppet::Environments::Cached.new(mocked_loader)
 
@@ -526,25 +623,97 @@ config_version=$vardir/random/scripts
         cached.get(:cached)
       end
 
+      it "does not list deleted environments" do
+        env3 = FS::MemoryFile.a_directory("env3", [
+          FS::MemoryFile.a_regular_file_containing("environment.conf", '')
+        ])
+
+        envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+          FS::MemoryFile.a_directory("env1", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", '')
+          ]),
+          FS::MemoryFile.a_directory("env2", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", '')
+          ]),
+          env3
+        ])
+
+        loader_from(:filesystem => [envdir], :directory => envdir) do |loader|
+          cached = Puppet::Environments::Cached.new(loader)
+          cached.get(:env1)
+          cached.get(:env2)
+          cached.get(:env3)
+          env3.extend(FsRemove).remove
+
+          expect(cached.list).to contain_exactly(environment(:env1),environment(:env2))
+          expect(cached.get(:env3)).to be_nil
+        end
+      end
+
+      it "normalizes environment name to symbol" do
+        env = Puppet::Node::Environment.create(:cached, [])
+        mocked_loader = double('loader')
+
+        expect(mocked_loader).not_to receive(:get).with('cached')
+        expect(mocked_loader).to receive(:get).with(:cached).and_return(env).once
+        expect(mocked_loader).to receive(:get_conf).with(:cached).and_return(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+        cached.get('cached')
+        cached.get(:cached)
+      end
+
+      it "caches environment name as symbol and only once" do
+        mocked_loader = double('loader')
+
+        env = Puppet::Node::Environment.create(:cached, [])
+        allow(mocked_loader).to receive(:get).with(:cached).and_return(env)
+        allow(mocked_loader).to receive(:get_conf).with(:cached).and_return(Puppet::Settings::EnvironmentConf.static_for(env, 20))
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+        cached.get(:cached)
+        cached.get('cached')
+
+        expect(cached.instance_variable_get(:@cache).keys).to eq([:cached])
+      end
+
+      it "is able to cache multiple environments" do
+        mocked_loader = double('loader')
+
+        env1 = Puppet::Node::Environment.create(:env1, [])
+        allow(mocked_loader).to receive(:get).with(:env1).and_return(env1)
+        allow(mocked_loader).to receive(:get_conf).with(:env1).and_return(Puppet::Settings::EnvironmentConf.static_for(env1, 20))
+
+        env2 = Puppet::Node::Environment.create(:env2, [])
+        allow(mocked_loader).to receive(:get).with(:env2).and_return(env2)
+        allow(mocked_loader).to receive(:get_conf).with(:env2).and_return(Puppet::Settings::EnvironmentConf.static_for(env2, 20))
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+        cached.get('env1')
+        cached.get('env2')
+
+        expect(cached.instance_variable_get(:@cache).keys).to eq([:env1, :env2])
+      end
+
       it "returns nil if env not found" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree) 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) 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
 
       it "does not reload the environment if it isn't expired" do
         env = Puppet::Node::Environment.create(:cached, [])
-        mocked_loader = mock('loader')
-        mocked_loader.expects(:get).with(:cached).returns(env).once
-        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
+        mocked_loader = double('loader')
+        expect(mocked_loader).to receive(:get).with(:cached).and_return(env).once
+        expect(mocked_loader).to receive(:get_conf).with(:cached).and_return(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
 
         cached = Puppet::Environments::Cached.new(mocked_loader)
 
@@ -553,19 +722,322 @@ config_version=$vardir/random/scripts
       end
 
       it "raises error if environment is not found" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree) 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
 
-    it "gets an environment.conf" do
-      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
-        expect(Puppet::Environments::Cached.new(loader).get_conf(:an_environment)).to match_environment_conf(:an_environment).
-          with_env_path(directory_tree).
-          with_global_module_path([])
+    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 "normalizes environment name to symbol" 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 }
+
+      it "notifies when the environment is first created" do
+        with_environment_loaded(service)
+
+        expect(service.created_envs).to eq([:an_environment])
+      end
+
+      it "does not evict an unexpired environment" do
+        Puppet[:environment_timeout] = 'unlimited'
+
+        with_environment_loaded(service) do |cached|
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment])
+        expect(service.evicted_envs).to eq([])
+      end
+
+      it "evicts an expired environment" do
+        expect(service).to receive(:expired?).and_return(true)
+
+        with_environment_loaded(service) do |cached|
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
+
+      it "evicts an environment that hasn't been recently touched" do
+        Puppet[:environment_timeout] = 1
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        with_environment_loaded(service) do |cached|
+          future = Time.now + 60
+          expect(Time).to receive(:now).and_return(future).at_least(:once)
+
+          # this should cause the cached environment to be evicted and a new one created
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+
+      end
+
+      it "reuses an environment that was recently touched" do
+        Puppet[:environment_timeout] = 60
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        with_environment_loaded(service) do |cached|
+          # reuse the already cached environment
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment])
+        expect(service.evicted_envs).to eq([])
+      end
+
+      it "evicts a recently touched environment" do
+        Puppet[:environment_timeout] = 60
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        expect(service).to receive(:expired?).and_return(true)
+
+        with_environment_loaded(service) do |cached|
+          # even though the environment was recently touched, it's been expired
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
+
+      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
+
+      context "when guarding an environment" do
+        before :each do
+          Puppet[:environment_timeout] = 0
+        end
+
+        let(:name) { :an_environment }
+
+        def with_guard(cached, name, &block)
+          cached.guard(name)
+          begin
+            yield
+          ensure
+            cached.unguard(name)
+          end
+        end
+
+        it "evicts an expired and unguarded environment" do
+          with_environment_loaded(service) do |cached|
+            cached.get!(name)
+          end
+
+          expect(service.created_envs).to eq([name, name])
+          expect(service.evicted_envs).to eq([name])
+        end
+
+        it "does not evict an expired, but guarded environment" do
+          with_environment_loaded(service) do |cached|
+            with_guard(cached, name) do
+              cached.get!(name) # these shouldn't reload
+              cached.get!(name)
+            end
+          end
+
+          expect(service.created_envs).to eq([name])
+          expect(service.evicted_envs).to eq([])
+        end
+
+        it "does not evict an environment marked for expiration, but is guarded" do
+          Puppet[:environment_timeout] = 'unlimited'
+
+          expect(service).to receive(:expired?).never
+
+          with_environment_loaded(service) do |cached|
+            with_guard(cached, name) do
+              cached.get!(name)
+            end
+          end
+
+          expect(service.created_envs).to eq([name])
+          expect(service.evicted_envs).to eq([])
+        end
+
+        it "evicts an environment that is no longer guarded" do
+          with_environment_loaded(service) do |cached|
+            with_guard(cached, name) {}
+
+            cached.get!(name) # this reloads
+          end
+
+          expect(service.created_envs).to eq([name, name])
+          expect(service.evicted_envs).to eq([name])
+        end
+
+        it "can nest guards" do
+          with_environment_loaded(service) do |cached|
+            with_guard(cached, name) do
+              with_guard(cached, name) do
+                cached.get!(name) # doesn't reload
+              end
+            end
+          end
+
+          expect(service.created_envs).to eq([name])
+          expect(service.evicted_envs).to eq([])
+        end
+      end
+    end
+
+    context '#clear' do
+      let(:service) { ReplayExpirationService.new }
+
+      it "evicts an environment" do
+        with_environment_loaded(service) do |cached|
+          cached.clear(:an_environment)
+        end
+
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
+
+      it "normalizes environment name to symbol" do
+        with_environment_loaded(service) do |cached|
+          cached.clear('an_environment')
+        end
+
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
+    end
+
+    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|
+          cached.get(:an_environment)
+          cached.get(:another_environment)
+          cached.clear_all
+
+          expect(service.evicted_envs).to match([:an_environment, :another_environment])
+        end
+      end
+
+      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)
+
+          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
+
+      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(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
+
+      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
+
+      it 'deletes environment text domains' do
+        with_environment_loaded(service) do |cached|
+          cached.get(:an_environment)
+          cached.clear_all
+
+          expect(FastGettext.text_domain).to eq(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN)
+        end
       end
     end
   end
@@ -640,6 +1112,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(
@@ -662,31 +1148,33 @@ config_version=$vardir/random/scripts
     end
   end
 
-  class ReplayExpirationService
-    attr_reader :created_envs, :expired_envs, :evicted_envs
+  # The environment named `:an_environment` will already be loaded when the
+  # block is yielded to
+  def with_environment_loaded(service, &block)
+    loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+      using_expiration_service(service) do
+        cached = Puppet::Environments::Cached.new(loader)
+        cached.get!(:an_environment)
 
-    def initialize(expiration_sequence)
+        yield cached if block_given?
+      end
+    end
+  end
+
+  class ReplayExpirationService < Puppet::Environments::Cached::DefaultCacheExpirationService
+    attr_reader :created_envs, :evicted_envs
+
+    def initialize
       @created_envs = []
-      @expired_envs = []
       @evicted_envs = []
-      @expiration_sequence = expiration_sequence
     end
 
     def created(env)
       @created_envs << env.name
     end
 
-    def expired?(env_name)
-      # make expired? idempotent
-      return true if @expired_envs.include? (env_name)
-      @expired_envs << env_name
-      @expiration_sequence.pop
-    end
-
     def evicted(env_name)
       @evicted_envs << env_name
     end
   end
-
-end
 end