puppet 6.24.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/confine/feature_spec.rb

@@ -22,7 +22,7 @@ describe Puppet::Confine::Feature do
     end
 
     it "should use the Puppet features instance to test validity" do
-      Puppet.features.add(:myfeature) do true end
+      expect(Puppet.features).to receive(:myfeature?)
       @confine.valid?
     end
 

data/spec/unit/confine_spec.rb

@@ -2,12 +2,6 @@ require 'spec_helper'
 
 require 'puppet/confine'
 
-class Puppet::TestConfine < Puppet::Confine
-  def pass?(value)
-    false
-  end
-end
-
 describe Puppet::Confine do
   it "should require a value" do
     expect { Puppet::Confine.new }.to raise_error(ArgumentError)
@@ -39,7 +33,7 @@ describe Puppet::Confine do
 
   describe "when testing all values" do
     before do
-      @confine = Puppet::TestConfine.new(%w{a b c})
+      @confine = Puppet::Confine.new(%w{a b c})
       @confine.label = "foo"
     end
 
@@ -70,7 +64,7 @@ describe Puppet::Confine do
   end
 
   describe "when testing the result of the values" do
-    before { @confine = Puppet::TestConfine.new(%w{a b c d}) }
+    before { @confine = Puppet::Confine.new(%w{a b c d}) }
 
     it "should return an array with the result of the test for each value" do
       allow(@confine).to receive(:pass?).and_return(true)

data/spec/unit/context/trusted_information_spec.rb

@@ -4,11 +4,7 @@ require 'puppet/certificate_factory'
 require 'puppet/context/trusted_information'
 
 describe Puppet::Context::TrustedInformation, :unless => RUBY_PLATFORM == 'java' do
-  let(:key) do
-    key = Puppet::SSL::Key.new("myname")
-    key.generate
-    key
-  end
+  let(:key) { OpenSSL::PKey::RSA.new(Puppet[:keylength]) }
 
   let(:csr) do
     csr = Puppet::SSL::CertificateRequest.new("csr")
@@ -26,7 +22,7 @@ describe Puppet::Context::TrustedInformation, :unless => RUBY_PLATFORM == 'java'
 
     # The cert must be signed so that it can be successfully be DER-decoded later
     signer = Puppet::SSL::CertificateSigner.new
-    signer.sign(cert.content, key.content)
+    signer.sign(cert.content, key)
     cert
   end
 

data/spec/unit/defaults_spec.rb

@@ -65,9 +65,9 @@ describe "Defaults" do
   end
 
   describe '.default_digest_algorithm' do
-    it 'defaults to md5 when FIPS is not enabled' do
+    it 'defaults to sha256 when FIPS is not enabled' do
       allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(false)
-      expect(Puppet.default_digest_algorithm).to eq('md5')
+      expect(Puppet.default_digest_algorithm).to eq('sha256')
     end
 
     it 'defaults to sha256 when FIPS is enabled' do
@@ -77,9 +77,9 @@ describe "Defaults" do
   end
 
   describe '.supported_checksum_types' do
-    it 'defaults to md5, sha256, sha384, sha512, sha224 when FIPS is not enabled' do
+    it 'defaults to sha256, sha384, sha512, sha224, md5 when FIPS is not enabled' do
       allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(false)
-      expect(Puppet.default_file_checksum_types).to eq(%w[md5 sha256 sha384 sha512 sha224])
+      expect(Puppet.default_file_checksum_types).to eq(%w[sha256 sha384 sha512 sha224 md5])
     end
 
     it 'defaults to sha256, sha384, sha512, sha224 when FIPS is enabled' do
@@ -89,8 +89,8 @@ describe "Defaults" do
   end
 
   describe 'Puppet[:supported_checksum_types]' do
-    it 'defaults to md5, sha256, sha512, sha384, sha224' do
-      expect(Puppet.settings[:supported_checksum_types]).to eq(%w[md5 sha256 sha384 sha512 sha224])
+    it 'defaults to sha256, sha512, sha384, sha224, md5' do
+      expect(Puppet.settings[:supported_checksum_types]).to eq(%w[sha256 sha384 sha512 sha224 md5])
     end
 
     it 'should raise an error on an unsupported checksum type' do
@@ -182,72 +182,86 @@ describe "Defaults" do
     end
   end
 
-  describe "facterng" do
-    it "defaults to false" do
-      expect(Puppet[:facterng]).to be_falsey
-    end
-
-    it "raises an exception if facter-ng could not be loaded" do
-      allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_raise(LoadError)
-      allow(Facter).to receive(:value).with('facterversion').and_return('3.11.4')
+  describe "deprecated settings" do
+    it 'does not issue a deprecation warning by default' do
+      expect(Puppet).to receive(:deprecation_warning).never
 
-      expect{ Puppet.settings[:facterng] = true }.to raise_exception ArgumentError, 'facter-ng could not be loaded'
+      Puppet.initialize_settings
     end
+  end
 
-    context 'set logger' do
-      before do
-        @original_facter = Object.const_get(:Facter)
-
-        Object.send(:remove_const, :Facter)
-        facter = double('facter')
-        allow(facter).to receive(:value).with('facterversion').and_return('3.11.4')
-        Object.const_set(:Facter, facter)
-
-        allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_return(true)
-        allow(Facter).to receive(:respond_to?).and_return(false)
-      end
-
-      after do
-        Object.const_set(:Facter, @original_facter)
-      end
+  describe "the call hook for the cadir setting", unless: Puppet::Util::Platform.windows? do
+    it 'does not warn when the cadir is outside the puppet ssldir' do
+      FileUtils.mkdir_p(Puppet[:confdir])
+      # This is fun; in order to get the confdir setting from the spec_helper to
+      # not be deleted by the #unsafe_clear in Puppet::Settings#parse_config,
+      # we can code it into the confdir itself, and thus we can avoid getting
+      # that setting wiped out during Puppet.initialize_settings.
+      File.write(File.join(Puppet[:confdir], 'puppet.conf'),
+                 "cadir = /my/cool/path/for/my/cadir\n
+                  confdir = #{Puppet[:confdir]}")
+      expect(Puppet).to_not receive(:log_ca_migration_warning)
+      Puppet.initialize_settings
+      expect(Puppet[:cadir]).to eq("/my/cool/path/for/my/cadir")
+    end
 
-      it 'calls setup_facter_logging!' do
-        allow(Puppet::Util::Logging).to receive(:setup_facter_logging!).and_return(true)
-        Puppet.settings[:facterng] = true
-        expect(Puppet::Util::Logging).to have_received(:setup_facter_logging!).once
+    it 'does warn when the cadir is inside the puppet ssldir' do
+      FileUtils.mkdir_p(Puppet[:confdir])
+      cadir_location = File.join(Puppet[:ssldir], 'still_inside_ssldir')
+      # This is fun; in order to get the confdir setting from the spec_helper to
+      # not be deleted by the #unsafe_clear in Puppet::Settings#parse_config,
+      # we can code it into the confdir itself, and thus we can avoid getting
+      # that setting wiped out during Puppet.initialize_settings.
+      File.write(File.join(Puppet[:confdir], 'puppet.conf'),
+                 "cadir = #{cadir_location}\n
+                  confdir = #{Puppet[:confdir]}")
+      expect(Puppet).to receive(:log_ca_migration_warning).twice
+      Puppet.initialize_settings
+      expect(Puppet[:cadir]).to eq(cadir_location)
       end
-    end
   end
 
-  describe "deprecated settings" do
-    it 'does not issue a deprecation warning by default' do
-      expect(Puppet).to receive(:deprecation_warning).never
-
+  describe "the default cadir", :unless => Puppet::Util::Platform.windows?  do
+    it 'defaults to the puppetserver confdir' do
       Puppet.initialize_settings
+      expect(Puppet[:cadir]).to eq('/etc/puppetlabs/puppetserver/ca')
     end
 
-    it 'issues a deprecation warning when func3x_check is disabled' do
-      Puppet[:func3x_check] = false
-
-      expect(Puppet).to receive(:deprecation_warning).with("The 'func3x_check' setting is deprecated and will be removed in a future release.")
-
+    it 'returns an empty string for Windows platforms', :if => Puppet::Util::Platform.windows? do
       Puppet.initialize_settings
+      expect(Puppet[:cadir]).to eq("")
     end
   end
 
-  describe "the default cadir", :unless => Puppet::Util::Platform.windows?  do
-    it 'defaults to inside the ssldir if not migrated' do
-      expect(File).to receive(:exist?).with('/etc/puppetlabs/puppetserver/ca/ca_crt.pem').and_return(false)
-      expect(Puppet.default_cadir).to eq("#{Puppet[:ssldir]}/ca")
+  describe '#default_cadir', :unless => Puppet::Util::Platform.windows?  do
+    it 'returns the new puppetserver directory when no ca dir is present' do
+      expect(Puppet).to_not receive(:log_ca_migration_warning)
+      expect(Puppet.default_cadir).to eq('/etc/puppetlabs/puppetserver/ca')
     end
 
-    it 'returns the new location if there is CA content there' do
-      expect(File).to receive(:exist?).with('/etc/puppetlabs/puppetserver/ca/ca_crt.pem').and_return(true)
-      expect(Puppet.default_cadir).to eq('/etc/puppetlabs/puppetserver/ca')
+    it 'warns when a CA dir exists in the current ssldir' do
+      cadir = File.join(Puppet[:ssldir], 'ca')
+      FileUtils.mkdir_p(cadir)
+      expect(Puppet).to receive(:log_ca_migration_warning)
+      expect(Puppet.default_cadir).to eq(cadir)
     end
 
-    it 'returns an empty string for Windows platforms', :if => Puppet::Util::Platform.windows? do
-      expect(Puppet.default_cadir).to eq("")
+    it 'warns when the cadir is a symlink still inside the ssldir' do
+      another_dir = File.join(Puppet[:ssldir], 'another_dir')
+      cadir = File.join(Puppet[:ssldir], 'ca')
+      FileUtils.mkdir_p(another_dir)
+      File.symlink(another_dir, cadir)
+      expect(Puppet).to receive(:log_ca_migration_warning)
+      expect(Puppet.default_cadir).to eq(another_dir)
+    end
+
+    it 'does not warn when the cadir is a symlink targeted outside the ssldir' do
+      another_dir = Dir.mktmpdir
+      cadir = File.join(Puppet[:ssldir], 'ca')
+      FileUtils.mkdir_p(Puppet[:ssldir])
+      File.symlink(another_dir, cadir)
+      expect(Puppet).to_not receive(:log_ca_migration_warning)
+      expect(Puppet.default_cadir).to eq(another_dir)
     end
   end
 end

data/spec/unit/environments_spec.rb

@@ -1,17 +1,14 @@
 require 'spec_helper'
 require 'puppet/environments'
 require 'puppet/file_system'
+require 'matchers/include'
+require 'matchers/include_in_order'
 
+module PuppetEnvironments
 describe Puppet::Environments do
-  FS = Puppet::FileSystem
+  include Matchers::Include
 
-  module FsRemove
-    def remove
-      @properties[:directory?] = false
-      @properties[:exist?] = false
-      @properties[:executable?] = false
-    end
-  end
+  FS = Puppet::FileSystem
 
   before(:each) do
     Puppet.settings.initialize_global_settings
@@ -52,7 +49,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 contain_exactly(
+        expect(loader.list).to include_in_any_order(
           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",
@@ -90,7 +87,7 @@ describe Puppet::Environments do
 
       loader_from(:filesystem => [envdir],
                   :directory => envdir) do |loader|
-        expect(loader.list).to contain_exactly(environment(:env1), environment(:env2))
+        expect(loader.list).to include_in_any_order(environment(:env1), environment(:env2))
       end
     end
 
@@ -409,29 +406,33 @@ config_version=$vardir/random/scripts
           ]),
         ])
 
-        cached_loader_from(:filesystem => [original_envdir], :directory => original_envdir) do |loader|
-          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(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")
+            FS.overlay(changed_envdir) do
+              changed_env = loader.get("env3")
 
-            expect(original_env).to environment(:env3).
-              with_manifest(File.expand_path("/manifest_orig")).
-              with_full_modulepath([File.expand_path("/modules_orig")])
+              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")])
+              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
@@ -557,49 +558,24 @@ config_version=$vardir/random/scripts
 
   describe "cached loaders" do
     it "lists environments" do
-      cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-        expect(loader.list).to contain_exactly(
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        expect(Puppet::Environments::Cached.new(loader).list).to include_in_any_order(
           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
-      cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-        expect(loader.search_paths).to eq(["file://#{directory_tree.children.first}"])
+      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}"])
       end
     end
 
     context "#get" do
       it "gets an environment" do
-        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-          expect(loader.get(:an_environment)).to environment(:an_environment)
+        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)
         end
       end
 
@@ -615,44 +591,17 @@ 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 "returns nil if env not found" do
-        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-          expect(loader.get(:doesnotexist)).to be_nil
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+          expect(Puppet::Environments::Cached.new(loader).get(:doesnotexist)).to be_nil
         end
       end
     end
 
     context "#get!" do
       it "gets an environment" do
-        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
-          expect(loader.get!(:an_environment)).to environment(:an_environment)
+        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)
         end
       end
 
@@ -669,43 +618,29 @@ config_version=$vardir/random/scripts
       end
 
       it "raises error if environment is not found" do
-        cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
           expect do
-            loader.get!(:doesnotexist)
+            Puppet::Environments::Cached.new(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)
+    context "expiration policies" do
+      let(:service) { ReplayExpirationService.new }
 
-        cached.get_conf(:cached)
-        cached.get_conf(:cached)
-      end
+      # 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)
 
-      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
+            yield cached if block_given?
+          end
         end
       end
-    end
-
-    context "expiration policies" do
-      let(:service) { ReplayExpirationService.new }
 
       it "notifies when the environment is first created" do
         with_environment_loaded(service)
@@ -725,7 +660,12 @@ config_version=$vardir/random/scripts
       end
 
       it "evicts an expired environment" do
-        expect(service).to receive(:expired?).and_return(true)
+        service = ReplayExpirationService.new
+
+        # The `Cached#clear_all_expired` method tries to optimize the case where
+        # no entries are expired. But if `Time.now < @next_expiration` and there is
+        # an expired entry, then the `service#expired?` method is called twice.
+        expect(service).to receive(:expired?).twice.and_return(true)
 
         with_environment_loaded(service) do |cached|
           cached.get!(:an_environment)
@@ -737,7 +677,6 @@ config_version=$vardir/random/scripts
 
       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
@@ -754,7 +693,6 @@ config_version=$vardir/random/scripts
 
       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
@@ -767,9 +705,9 @@ config_version=$vardir/random/scripts
 
       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)
+        # see note above about "twice"
+        expect(service).to receive(:expired?).twice.and_return(true)
 
         with_environment_loaded(service) do |cached|
           # even though the environment was recently touched, it's been expired
@@ -779,116 +717,13 @@ config_version=$vardir/random/scripts
         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
     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
-    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
+    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([])
       end
     end
   end
@@ -963,20 +798,6 @@ 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(
@@ -999,19 +820,6 @@ config_version=$vardir/random/scripts
     end
   end
 
-  # 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)
-
-        yield cached if block_given?
-      end
-    end
-  end
-
   class ReplayExpirationService < Puppet::Environments::Cached::DefaultCacheExpirationService
     attr_reader :created_envs, :evicted_envs
 
@@ -1029,3 +837,4 @@ config_version=$vardir/random/scripts
     end
   end
 end
+end