puppet 7.6.1-x86-mingw32 → 7.10.0-x86-mingw32

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/lib/puppet_spec/modules.rb

@@ -36,7 +36,7 @@ module PuppetSpec::Modules
         end
       end
 
-      if plans = options[:plans]
+      if (plans = options[:plans])
         plans_dir = File.join(module_dir, 'plans')
         FileUtils.mkdir_p(plans_dir)
         plans.each do |plan_file|
@@ -48,6 +48,17 @@ module PuppetSpec::Modules
         end
       end
 
+      if (scripts = options[:scripts])
+        scripts_dir = File.join(module_dir, 'scripts')
+        FileUtils.mkdir_p(scripts_dir)
+        scripts.each do |script_file|
+          if script_file.is_a?(String)
+            script_file = { :name => script_file, :content => "" }
+          end
+          File.write(File.join(scripts_dir, script_file[:name]), script_file[:content])
+        end
+      end
+
       (options[:files] || {}).each do |fname, content|
         path = File.join(module_dir, fname)
         FileUtils.mkdir_p(File.dirname(path))
@@ -61,7 +72,7 @@ module PuppetSpec::Modules
       module_dir = File.join(dir, name)
       FileUtils.mkdir_p(module_dir)
 
-      if metadata = options[:metadata]
+      if (metadata = options[:metadata])
         File.open(File.join(module_dir, 'metadata.json'), 'w') do |f|
           f.write(metadata.to_json)
         end

data/spec/lib/puppet_spec/puppetserver.rb

@@ -31,6 +31,19 @@ class PuppetSpec::Puppetserver
     end
   end
 
+  class FileMetadataServlet < WEBrick::HTTPServlet::AbstractServlet
+    def do_GET request, response
+      response['Content-Type'] = 'application/json'
+      response.body = "{\"path\":\"/etc/puppetlabs/code/environments/production/modules\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-03-06 20:14:25 UTC\"},\"type\":\"directory\",\"destination\":null}"
+    end
+  end
+
+  class FileContentServlet < WEBrick::HTTPServlet::AbstractServlet
+    def do_GET request, response
+      response.status = 404
+    end
+  end
+
   class ReportServlet < WEBrick::HTTPServlet::AbstractServlet
     def do_PUT request, response
       response['Content-Type'] = 'application/json'
@@ -106,7 +119,9 @@ class PuppetSpec::Puppetserver
     register_mount('/status/v1/simple/server', proc { |req, res|  }, nil)
     register_mount('/puppet/v3/node', mounts[:node], NodeServlet)
     register_mount('/puppet/v3/catalog', mounts[:catalog], CatalogServlet)
+    register_mount('/puppet/v3/file_metadata', mounts[:file_metadata], FileMetadataServlet)
     register_mount('/puppet/v3/file_metadatas', mounts[:file_metadatas], FileMetadatasServlet)
+    register_mount('/puppet/v3/file_content', mounts[:file_content], FileContentServlet)
     register_mount('/puppet/v3/static_file_content', mounts[:static_file_content], StaticFileContentServlet)
     register_mount('/puppet/v3/report', mounts[:report], ReportServlet)
     register_mount('/puppet/v3/file_bucket_file', mounts[:filebucket], FilebucketServlet)

data/spec/lib/puppet_spec/settings.rb

@@ -21,6 +21,7 @@ module PuppetSpec::Settings
   end.freeze
 
   def set_puppet_conf(confdir, settings)
+    FileUtils.mkdir_p(confdir)
     write_file(File.join(confdir, "puppet.conf"), settings)
   end
 

data/spec/shared_behaviours/documentation_on_faces.rb

@@ -176,8 +176,6 @@ shared_examples_for "documentation on faces" do
       subject.license = "foo"
       expect(subject.license).to eq("foo")
     end
-
-    it "should accept symbols to specify existing licenses..."
   end
 
   describe "#copyright" do

data/spec/shared_contexts/l10n.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.shared_context('l10n') do |locale|
+  before :all do
+    @old_locale = Locale.current
+    Locale.current = locale
+    Puppet::GettextConfig.setup_locale
+
+    # overwrite stubs with real implementation
+    ::Object.send(:remove_method, :_)
+    ::Object.send(:remove_method, :n_)
+    class ::Object
+      include FastGettext::Translation
+    end
+  end
+
+  after :all do
+    Locale.current = @old_locale
+
+    # restore stubs
+    load File.expand_path(File.join(__dir__, '../../lib/puppet/gettext/stubs.rb'))
+  end
+
+  before :each do
+    Puppet[:disable_i18n] = false
+  end
+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

@@ -68,16 +68,7 @@ VCR.turn_off!
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 
-  # Examples or groups can selectively tag themselves as broken.
-  # For example;
-  #
-  # rbv = "#{RUBY_VERSION}-p#{RbConfig::CONFIG['PATCHLEVEL']}"
-  # describe "mostly working", :broken => false unless rbv == "1.9.3-p327" do
-  #  it "parses a valid IP" do
-  #    IPAddr.new("::2:3:4:5:6:7:8")
-  #  end
-  # end
-  exclude_filters = {:broken => true}
+  exclude_filters = {}
   exclude_filters[:benchmark] = true unless ENV['BENCHMARK']
   config.filter_run_excluding exclude_filters
 

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/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

@@ -7,6 +7,9 @@ describe Puppet::Configurer do
     Puppet[:report] = true
 
     catalog.add_resource(resource)
+    allow_any_instance_of(described_class).to(
+      receive(:valid_server_environment?).and_return(true)
+    )
   end
 
   let(:node_name) { Puppet[:node_name_value] }
@@ -78,10 +81,10 @@ describe Puppet::Configurer do
       configurer.run(:pluginsync => false)
     end
 
-    it "should carry on when it can't fetch its node definition" do
-      error = Net::HTTPError.new(400, 'dummy server communication error')
-      expect(Puppet::Node.indirection).to receive(:find).and_raise(error)
-      expect(configurer.run).to eq(0)
+    it "does not download plugins when specified environment is not vaild on server" do
+      expect(configurer).to receive(:valid_server_environment?).and_return(false)
+      expect(configurer).not_to receive(:download_plugins)
+      configurer.run(:pluginsync => true)
     end
 
     it "fails the run if pluginsync fails when usecacheonfailure is false" do
@@ -125,7 +128,6 @@ describe Puppet::Configurer do
     it "applies a cached catalog when it can't connect to the master" do
       error = Errno::ECONNREFUSED.new('Connection refused - connect(2)')
 
-      expect(Puppet::Node.indirection).to receive(:find).and_raise(error)
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(:ignore_cache => true)).and_raise(error)
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(:ignore_terminus => true)).and_return(catalog)
 
@@ -149,6 +151,126 @@ describe Puppet::Configurer do
       expect(report.host).to eq('node_name_from_fact')
     end
 
+    it "should warn the user when the fact value length limits are exceeded" do
+      Puppet[:fact_name_length_soft_limit] = 0
+      Puppet[:fact_value_length_soft_limit] = 1
+      Puppet[:top_level_facts_soft_limit] = 0
+      Puppet[:number_of_facts_soft_limit] = 0
+      Puppet[:payload_soft_limit] = 0
+
+      facts.values = { 'processors' => {
+        'cores' => 1,
+        'count' => 2,
+        'isa' => "i386",
+        'models' => [
+          "CPU1 @ 2.80GHz"
+        ],
+        'physicalcount' => 4 }
+      }
+      Puppet::Node::Facts.indirection.save(facts)
+
+      expect(Puppet).to receive(:warning).with(/Fact value '.+' with the value length: '[1-9]*' exceeds the value length limit: [1-9]*/).twice
+      configurer.run
+    end
+
+    it "should warn the user when the payload limits are exceeded" do
+      Puppet[:fact_name_length_soft_limit] = 0
+      Puppet[:fact_value_length_soft_limit] = 0
+      Puppet[:top_level_facts_soft_limit] = 0
+      Puppet[:number_of_facts_soft_limit] = 0
+      Puppet[:payload_soft_limit] = 1
+
+      facts.values = { 'processors' => {
+        'cores' => 1,
+        'count' => 2,
+        'isa' => "i386",
+        'models' => [
+          "CPU1 @ 2.80GHz"
+        ],
+        'physicalcount' => 4 }
+      }
+      Puppet::Node::Facts.indirection.save(facts)
+
+      expect(Puppet).to receive(:warning).with(/Payload with the current size of: '[1-9]*' exceeds the payload size limit: [1-9]*/)
+      configurer.run
+    end
+
+    it "should warn the user when the total number of facts limit is exceeded" do
+      Puppet[:fact_name_length_soft_limit] = 0
+      Puppet[:fact_value_length_soft_limit] = 0
+      Puppet[:top_level_facts_soft_limit] = 0
+      Puppet[:number_of_facts_soft_limit] = 1
+      Puppet[:payload_soft_limit] = 0
+
+      facts.values = { 
+        'processors' => {
+          'cores' => 1,
+          'count' => 2,
+          'isa' => "i386",
+          'models' => [
+            "CPU1 @ 2.80GHz",
+            "CPU1 @ 2.80GHz",
+            "CPU1 @ 2.80GHz",
+            "CPU1 @ 2.80GHz",
+            "CPU1 @ 2.80GHz",
+            { 
+              'processors' => {
+                'cores' => [1,2]
+              }
+            }
+          ],
+          'physicalcount' => 4 
+        }
+      }
+      Puppet::Node::Facts.indirection.save(facts)
+
+      expect(Puppet).to receive(:warning).with(/The current total number of facts: [1-9]* exceeds the number of facts limit: [1-9]*/)
+      configurer.run
+    end
+
+    it "should warn the user when the top level facts size limits are exceeded" do
+      Puppet[:fact_name_length_soft_limit] = 0
+      Puppet[:fact_value_length_soft_limit] = 0
+      Puppet[:top_level_facts_soft_limit] = 1
+      Puppet[:number_of_facts_soft_limit] = 0
+      Puppet[:payload_soft_limit] = 0
+
+      facts.values = {'my_new_fact_name' => 'my_new_fact_value',
+                      'my_new_fact_name2' => 'my_new_fact_value2'}
+      Puppet::Node::Facts.indirection.save(facts)
+
+      expect(Puppet).to receive(:warning).with(/The current number of top level facts: [1-9]* exceeds the top facts limit: [1-9]*/)
+      configurer.run
+    end
+
+    it "should warn the user when the fact name length limits are exceeded" do
+      Puppet[:fact_name_length_soft_limit] = 1
+      Puppet[:fact_value_length_soft_limit] = 0
+      Puppet[:top_level_facts_soft_limit] = 0
+      Puppet[:number_of_facts_soft_limit] = 0
+      Puppet[:payload_soft_limit] = 0
+
+      facts.values = {'my_new_fact_name' => 'my_new_fact_value'}
+      Puppet::Node::Facts.indirection.save(facts)
+
+      expect(Puppet).to receive(:warning).with(/Fact .+ with length: '[1-9]*' exceeds the length limit: [1-9]*/)
+      configurer.run
+    end
+
+    it "shouldn't warn the user when the fact limit settings are set to 0" do
+      Puppet[:fact_name_length_soft_limit] = 0
+      Puppet[:fact_value_length_soft_limit] = 0
+      Puppet[:top_level_facts_soft_limit] = 0
+      Puppet[:number_of_facts_soft_limit] = 0
+      Puppet[:payload_soft_limit] = 0
+
+      facts.values = {'my_new_fact_name' => 'my_new_fact_value'}
+      Puppet::Node::Facts.indirection.save(facts)
+
+      expect(Puppet).not_to receive(:warning)
+      configurer.run
+    end
+
     it "creates a new report when applying the catalog" do
       options = {}
       configurer.run(options)
@@ -553,24 +675,6 @@ describe Puppet::Configurer do
     end
   end
 
-  describe "when requesting a node" do
-    it "uses the transaction uuid in the request" do
-      expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(transaction_uuid: anything)).twice
-      configurer.run
-    end
-
-    it "sends an explicitly configured environment request" do
-      expect(Puppet.settings).to receive(:set_by_config?).with(:environment).and_return(true)
-      expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(configured_environment: Puppet[:environment])).twice
-      configurer.run
-    end
-
-    it "does not send a configured_environment when using the default" do
-      expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(configured_environment: nil)).twice
-      configurer.run
-    end
-  end
-
   def expects_pluginsync
     metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":420,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
     stub_request(:get, %r{/puppet/v3/file_metadatas/(plugins|locales)}).to_return(status: 200, body: metadata, headers: {'Content-Type' => 'application/json'})
@@ -581,7 +685,7 @@ describe Puppet::Configurer do
   end
 
   def expects_new_catalog_only(catalog)
-    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
+    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true, check_environment: true)).and_return(catalog)
     expect(Puppet::Resource::Catalog.indirection).not_to receive(:find).with(anything, hash_including(ignore_terminus: true))
   end
 
@@ -598,7 +702,7 @@ describe Puppet::Configurer do
   def expects_fallback_to_new_catalog(catalog)
     expects_pluginsync
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(nil)
-    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
+    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true, check_environment: true)).and_return(catalog)
   end
 
   def expects_neither_new_or_cached_catalog
@@ -622,21 +726,13 @@ describe Puppet::Configurer do
         configurer.run
       end
 
-      it "should not make a node request or pluginsync when a cached catalog is successfully retrieved" do
-        expect(Puppet::Node.indirection).not_to receive(:find)
+      it "should not pluginsync when a cached catalog is successfully retrieved" do
         expects_cached_catalog_only(catalog)
         expect(configurer).not_to receive(:download_plugins)
 
         configurer.run
       end
 
-      it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
-        expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
-        expects_fallback_to_new_catalog(catalog)
-
-        configurer.run
-      end
-
       it "should set its cached_catalog_status to 'explicitly_requested'" do
         expects_cached_catalog_only(catalog)
 
@@ -672,7 +768,6 @@ describe Puppet::Configurer do
       it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
         Puppet[:ignore_plugin_errors] = true
 
-        expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_neither_new_or_cached_catalog
         expects_pluginsync
 
@@ -728,16 +823,6 @@ describe Puppet::Configurer do
         Puppet.settings[:strict_environment_mode] = true
       end
 
-      it "should not make a node request" do
-        stub_request(:get, %r{/puppet/v3/file_metadatas?/plugins}).to_return(:status => 404)
-        stub_request(:get, %r{/puppet/v3/file_metadatas?/pluginfacts}).to_return(:status => 404)
-        expects_new_catalog_only(catalog)
-
-        expect(Puppet::Node.indirection).not_to receive(:find)
-
-        configurer.run
-      end
-
       it "should return nil when the catalog's environment doesn't match the agent specified environment" do
         Puppet[:environment] = 'second_env'
         configurer = Puppet::Configurer.new
@@ -951,9 +1036,23 @@ describe Puppet::Configurer do
       expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(apple, banana, banana)
 
       allow(Puppet).to receive(:notice)
+      allow(Puppet).to receive(:push_context)
       expect(Puppet).to receive(:notice).with("Local environment: 'production' doesn't match server specified environment 'apple', restarting agent run with environment 'apple'")
       expect(Puppet).to receive(:notice).with("Local environment: 'apple' doesn't match server specified environment 'banana', restarting agent run with environment 'banana'")
 
+      expect(Puppet).to receive(:push_context).with(
+        hash_including(current_environment: an_object_having_attributes(name: :production)),
+        'Local node environment production for configurer transaction'
+      )
+      expect(Puppet).to receive(:push_context).with(
+        hash_including(current_environment: an_object_having_attributes(name: :apple)),
+        'Local node environment apple for configurer transaction'
+      )
+      expect(Puppet).to receive(:push_context).with(
+        hash_including(current_environment: an_object_having_attributes(name: :banana)),
+        'Local node environment banana for configurer transaction'
+      )
+
       configurer.run
     end
 
@@ -1075,6 +1174,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
@@ -1087,20 +1209,132 @@ describe Puppet::Configurer do
       expect(configurer.run(options)).to eq(0)
       expect(options[:report].server_used).to be_nil
     end
+  end
 
-    it "should not make multiple node requests when the server is found" do
-      Puppet.settings[:server_list] = ["myserver:123"]
+  describe "when selecting an environment" do
+    include PuppetSpec::Files
+    include PuppetSpec::Settings
 
-      Puppet::Node.indirection.terminus_class = :rest
-      Puppet::Resource::Catalog.indirection.terminus_class = :rest
+    describe "when the last used environment is available" do
+      let(:last_server_specified_environment) { 'development' }
 
-      stub_request(:get, 'https://myserver:123/status/v1/simple/server').to_return(status: 200)
-      stub_request(:post, %r{https://myserver:123/puppet/v3/catalog}).to_return(status: 200)
-      node_request = stub_request(:get, %r{https://myserver:123/puppet/v3/node/}).to_return(status: 200)
+      before do
+        Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', <<~SUMMARY)
+        ---
+        version:
+          config: 1624882680
+          puppet: 6.24.0
+        application:
+          initial_environment: #{Puppet[:environment]}
+          converged_environment: #{last_server_specified_environment}
+          run_mode: agent
+        SUMMARY
+      end
 
-      configurer.run
+      it "prefers the environment set via cli" do
+        Puppet.settings.handlearg('--environment', 'usethis')
+        configurer.run
+
+        expect(configurer.environment).to eq('usethis')
+      end
+
+      it "prefers the environment set via config" do
+        FileUtils.mkdir_p(Puppet[:confdir])
+        set_puppet_conf(Puppet[:confdir], <<~CONF)
+        [main]
+        environment = usethis
+        CONF
+
+        Puppet.initialize_settings
+        configurer.run
 
-      expect(node_request).to have_been_requested.once
+        expect(configurer.environment).to eq('usethis')
+      end
+
+      it "uses environment from Puppet[:environment] if given a catalog" do
+        configurer.run(catalog: catalog)
+
+        expect(configurer.environment).to eq(Puppet[:environment])
+      end
+
+      it "uses environment from Puppet[:environment] if use_cached_catalog = true" do
+        Puppet[:use_cached_catalog] = true
+        expects_cached_catalog_only(catalog)
+        configurer.run
+
+        expect(configurer.environment).to eq(Puppet[:environment])
+      end
+
+      describe "when the environment is not set via CLI" do
+        it "uses the environment found in lastrunfile if the key exists" do
+          configurer.run
+
+          expect(configurer.environment).to eq(last_server_specified_environment)
+        end
+
+        it "uses environment from Puppet[:environment] if strict_environment_mode is set" do
+          Puppet[:strict_environment_mode] = true
+          configurer.run
+
+          expect(configurer.environment).to eq(Puppet[:environment])
+        end
+
+        it "uses environment from Puppet[:environment] if initial_environment is the same as converged_environment" do
+          Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', <<~SUMMARY)
+          ---
+          version:
+            config: 1624882680
+            puppet: 6.24.0
+          application:
+            initial_environment: development
+            converged_environment: development
+            run_mode: agent
+          SUMMARY
+          configurer.run
+
+          expect(configurer.environment).to eq(Puppet[:environment])
+        end
+
+        it "uses environment from Puppet[:environment] if the run mode doesn't match" do
+          Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', <<~SUMMARY)
+          ---
+          version:
+            config: 1624882680
+            puppet: 6.24.0
+          application:
+            initial_environment: #{Puppet[:environment]}
+            converged_environment: #{last_server_specified_environment}
+            run_mode: user
+          SUMMARY
+          configurer.run
+
+          expect(configurer.environment).to eq(Puppet[:environment])
+        end
+
+        it "uses environment from Puppet[:environment] if lastrunfile is invalid YAML" do
+          Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', <<~SUMMARY)
+          Key: 'this is my very very very ' +
+               'long string'
+          SUMMARY
+          configurer.run
+
+          expect(configurer.environment).to eq(Puppet[:environment])
+        end
+
+        it "uses environment from Puppet[:environment] if lastrunfile exists but is empty" do
+          Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', '')
+          configurer.run
+
+          expect(configurer.environment).to eq(Puppet[:environment])
+        end
+
+        it "uses environment from Puppet[:environment] if the last used one cannot be found" do
+          Puppet[:lastrunfile] = tmpfile('last_run_summary.yaml')
+          configurer.run
+
+          expect(configurer.environment).to eq(Puppet[:environment])
+        end
+      end
     end
   end
 end