puppet 6.23.0-universal-darwin → 6.26.0-universal-darwin

data/spec/integration/application/agent_spec.rb

@@ -472,67 +472,58 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
   end
 
   context 'multiple agents running' do
-    it "exits if an agent is already running" do
+    def with_another_agent_running(&block)
       path = Puppet[:agent_catalog_run_lockfile]
 
       th = Thread.new {
-        %x{ruby -e "$0 = 'puppet'; File.write('#{path}', Process.pid); sleep(2)"}
+        %x{ruby -e "$0 = 'puppet'; File.write('#{path}', Process.pid); sleep(5)"}
       }
 
+      # ensure file is written before yielding
       until File.exists?(path) && File.size(path) > 0 do
         sleep 0.1
       end
 
-      expect {
-        agent.command_line.args << '--test'
-        agent.run
-      }.to exit_with(1).and output(/Run of Puppet configuration client already in progress; skipping/).to_stdout
+      begin
+        yield
+      ensure
+        th.kill # kill thread so we don't wait too much
+      end
+    end
 
-      th.kill # kill thread so we don't wait too much
+    it "exits if an agent is already running" do
+      with_another_agent_running do
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(1).and output(/Run of Puppet configuration client already in progress; skipping/).to_stdout
+      end
     end
 
     it "waits for other agent run to finish before starting" do
       server.start_server do |port|
-        path = Puppet[:agent_catalog_run_lockfile]
         Puppet[:serverport] = port
         Puppet[:waitforlock] = 1
 
-        th = Thread.new {
-          %x{ruby -e "$0 = 'puppet'; File.write('#{path}', Process.pid); sleep(2)"}
-        }
-
-        until File.exists?(path) && File.size(path) > 0 do
-          sleep 0.1
+        with_another_agent_running do
+          expect {
+            agent.command_line.args << '--test'
+            agent.run
+          }.to exit_with(0).and output(/Info: Will try again in #{Puppet[:waitforlock]} seconds./).to_stdout
         end
-
-        expect {
-          agent.command_line.args << '--test'
-          agent.run
-        }.to exit_with(0).and output(/Info: Will try again in #{Puppet[:waitforlock]} seconds./).to_stdout
-
-        th.kill # kill thread so we don't wait too much
       end
     end
 
     it "exits if maxwaitforlock is exceeded" do
-      path = Puppet[:agent_catalog_run_lockfile]
       Puppet[:waitforlock] = 1
       Puppet[:maxwaitforlock] = 0
 
-      th = Thread.new {
-        %x{ruby -e "$0 = 'puppet'; File.write('#{path}', Process.pid); sleep(2)"}
-      }
-
-      until File.exists?(path) && File.size(path) > 0 do
-        sleep 0.1
+      with_another_agent_running do
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(1).and output(/Exiting now because the maxwaitforlock timeout has been exceeded./).to_stdout
       end
-
-      expect {
-        agent.command_line.args << '--test'
-        agent.run
-      }.to exit_with(1).and output(/Exiting now because the maxwaitforlock timeout has been exceeded./).to_stdout
-
-      th.kill # kill thread so we don't wait too much
     end
   end
 
@@ -572,7 +563,7 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
        ).and matching(
          /Notify\[a message\]\/message:/
        )).to_stdout
-       .and output(/the agent run will continue/).to_stderr
+       .and output(/Could not retrieve catalog from remote server/).to_stderr
     end
 
     it 'preserves the old cached catalog if validation fails with the old one' do
@@ -591,7 +582,7 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
           agent.command_line.args << '--test'
           agent.run
         }.to exit_with(1)
-         .and output(/Using configured environment/).to_stdout
+         .and output(%r{Retrieving plugin}).to_stdout
          .and output(%r{Validation of Exec\[unqualified_command\] failed: 'unqualified_command' is not qualified and no path was specified}).to_stderr
       end
 
@@ -632,5 +623,118 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
         expect(report.metrics).to_not be_empty
       end
     end
+
+    it "caches a report even if the REST request fails" do
+      server.start_server do |port|
+        Puppet[:serverport] = port
+        Puppet[:report_port] = "-1"
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(0)
+         .and output(%r{Applied catalog}).to_stdout
+         .and output(%r{Could not send report}).to_stderr
+
+        report = Puppet::Transaction::Report.convert_from(:yaml, File.read(Puppet[:lastrunreport]))
+        expect(report).to be
+      end
+    end
+  end
+
+  context "environment convergence" do
+    it "falls back to making a node request if the last server-specified environment cannot be loaded" do
+      mounts = {}
+      mounts[:node] = -> (req, res) {
+        node = Puppet::Node.new('test', environment: Puppet::Node::Environment.remote('doesnotexistonagent'))
+        res.body = formatter.render(node)
+        res['Content-Type'] = formatter.mime
+      }
+
+      server.start_server(mounts: mounts) do |port|
+        Puppet[:serverport] = port
+        Puppet[:log_level] = 'debug'
+
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(0)
+         .and output(a_string_matching(%r{Debug: Requesting environment from the server})).to_stdout
+
+        Puppet::Application.clear!
+
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(0)
+         .and output(a_string_matching(%r{Debug: Successfully loaded last environment from the lastrunfile})).to_stdout
+      end
+    end
+
+    it "switches to 'newenv' environment and retries the run" do
+      first_run = true
+      libdir = File.join(my_fixture_dir, 'lib')
+
+      # we have to use the :facter terminus to reliably test that pluginsynced
+      # facts are included in the catalog request
+      Puppet::Node::Facts.indirection.terminus_class = :facter
+
+      mounts = {}
+
+      # During the first run, only return metadata for the top-level directory.
+      # During the second run, include metadata for all of the 'lib' fixtures
+      # due to the `recurse` option.
+      mounts[:file_metadatas] = -> (req, res) {
+        request = Puppet::FileServing::Metadata.indirection.request(
+          :search, libdir, nil, recurse: !first_run
+        )
+        data = Puppet::FileServing::Metadata.indirection.terminus(:file).search(request)
+        res.body = formatter.render(data)
+        res['Content-Type'] = formatter.mime
+      }
+
+      mounts[:file_content] = -> (req, res) {
+        request = Puppet::FileServing::Content.indirection.request(
+          :find, File.join(libdir, 'facter', 'agent_spec_role.rb'), nil
+        )
+        content = Puppet::FileServing::Content.indirection.terminus(:file).find(request)
+        res.body = content.content
+        res['Content-Length'] = content.content.length
+        res['Content-Type'] = 'application/octet-stream'
+      }
+
+      # During the first run, return an empty catalog referring to the newenv.
+      # During the second run, compile a catalog that depends on a fact that
+      # only exists in the second environment. If the fact is missing/empty,
+      # then compilation will fail since resources can't have an empty title.
+      mounts[:catalog] = -> (req, res) {
+        node = Puppet::Node.new('test')
+
+        code = if first_run
+                 first_run = false
+                 ''
+               else
+                 data = CGI.unescape(req.query['facts'])
+                 facts = Puppet::Node::Facts.convert_from('json', data)
+                 node.fact_merge(facts)
+                 'notify { $facts["agent_spec_role"]: }'
+               end
+
+        catalog = compile_to_catalog(code, node)
+        catalog.environment = 'newenv'
+
+        res.body = formatter.render(catalog)
+        res['Content-Type'] = formatter.mime
+      }
+
+      server.start_server(mounts: mounts) do |port|
+        Puppet[:serverport] = port
+        expect {
+          agent.command_line.args << '--test'
+          agent.run
+        }.to exit_with(2)
+         .and output(a_string_matching(%r{Notice: Local environment: 'production' doesn't match server specified environment 'newenv', restarting agent run with environment 'newenv'})
+         .and matching(%r{defined 'message' as 'web'})).to_stdout
+      end
+    end
   end
 end

data/spec/integration/application/filebucket_spec.rb

@@ -18,6 +18,11 @@ describe "puppet filebucket", unless: Puppet::Util::Platform.jruby? do
     File.binwrite(backup_file, text)
   end
 
+  after :each do
+    # mute debug messages generated during `after :each` blocks
+    Puppet::Util::Log.close_all
+  end
+
   it "backs up to and restores from the local filebucket" do
     filebucket.command_line.args = ['backup', backup_file, '--local']
     expect {
@@ -126,6 +131,17 @@ describe "puppet filebucket", unless: Puppet::Util::Platform.jruby? do
     end
   end
 
+  it "lists the local filebucket even if the environment doesn't exist locally" do
+    Puppet[:environment] = 'doesnotexist'
+    Puppet::FileSystem.mkpath(Puppet[:clientbucketdir])
+
+    filebucket.command_line.args = ['backup', '--local', backup_file]
+    expect {
+      result = filebucket.run
+      expect(result).to eq([backup_file])
+    }.to output(/Computing checksum on file/).to_stdout
+  end
+
   context 'diff', unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
     context 'using a remote bucket' do
       it 'outputs a diff between a local and remote file' do

data/spec/integration/application/lookup_spec.rb

@@ -7,6 +7,7 @@ describe 'lookup' do
   include PuppetSpec::Files
 
   context 'with an environment' do
+    let(:fqdn) { Puppet.runtime[:facter].value(:fqdn) }
     let(:env_name) { 'spec' }
     let(:env_dir) { tmpdir('environments') }
     let(:environment_files) do
@@ -44,12 +45,20 @@ describe 'lookup' do
     let(:app) { Puppet::Application[:lookup] }
     let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
     let(:environments) { Puppet::Environments::Directories.new(populated_env_dir, []) }
+    let(:facts) { Puppet::Node::Facts.new("facts", {'my_fact' => 'my_fact_value'}) }
+    let(:cert) { pem_content('oid.pem') }
 
+    let(:node) { Puppet::Node.new('testnode', :facts => facts, :environment => env) }
     let(:populated_env_dir) do
       dir_contained_in(env_dir, environment_files)
       env_dir
     end
 
+    before do
+      stub_request(:get, "https://puppet:8140/puppet-ca/v1/certificate/#{fqdn}").to_return(body: cert)
+      allow(Puppet::Node::Facts.indirection).to receive(:find).and_return(facts)
+    end
+
     def lookup(key, options = {}, explain = false)
       key = [key] unless key.is_a?(Array)
       allow(app.command_line).to receive(:args).and_return(key)
@@ -90,24 +99,41 @@ describe 'lookup' do
       expect(lookup('a')).to eql('value a')
     end
 
+    it 'loads trusted information from the node certificate' do
+      allow(Puppet).to receive(:override).and_call_original
+      expect(Puppet).to receive(:override).with(trusted_information: an_object_having_attributes(
+        certname: fqdn,
+        extensions: { "1.3.6.1.4.1.34380.1.2.1.1" => "somevalue" }))
+
+      Puppet.settings[:node_terminus] = 'exec'
+      expect_any_instance_of(Puppet::Node::Exec).to receive(:find).and_return(node)
+      lookup('a', :compile => true)
+    end
+
     it 'loads external facts when running without --node' do
       expect(Puppet::Util).not_to receive(:skip_external_facts)
       expect(Facter).not_to receive(:load_external)
       lookup('a')
     end
 
-    it 'skip loading of external facts when run with --node' do
-      app.options[:node] = "random_node"
-      expect(Facter).to receive(:load_external).once.with(false)
-      expect(Facter).to receive(:load_external).once.with(true)
-      lookup('a')
+    describe 'when using --node' do
+      let(:fqdn) { 'random_node' }
+
+      it 'skips loading of external facts' do
+        app.options[:node] = fqdn
+
+        expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(facts)
+        expect(Facter).to receive(:load_external).once.with(false)
+        expect(Facter).to receive(:load_external).once.with(true)
+        lookup('a')
+      end
     end
 
     context 'uses node_terminus' do
       require 'puppet/indirector/node/exec'
       require 'puppet/indirector/node/plain'
 
-      let(:node) { Puppet::Node.new('testnode', :environment => env) }
+      let(:node) { Puppet::Node.new('testnode', :facts => facts, :environment => env) }
 
       it ':plain without --compile' do
         Puppet.settings[:node_terminus] = 'exec'

data/spec/integration/application/module_spec.rb

@@ -65,4 +65,25 @@ describe 'puppet module', unless: Puppet::Util::Platform.jruby? do
        .and output(%r{Unable to verify the SSL certificate}).to_stderr
     end
   end
+
+  it 'prints the complete URL it tried to connect to' do
+    response_proc = -> (req, res) { res.status = 404 }
+
+    # create a temp cacert bundle
+    ssl_file = tmpfile('systemstore')
+    File.write(ssl_file, server.ca_cert)
+
+    Puppet::Util.withenv("SSL_CERT_FILE" => ssl_file) do
+      server.start_server(response_proc: response_proc) do |port|
+        Puppet[:module_repository] = "https://127.0.0.1:#{port}/bogus_test/puppet"
+
+        expect {
+          app.command_line.args = ['install', 'puppetlabs-bacula']
+          app.run
+        }.to exit_with(1)
+         .and output(%r{Notice: Downloading from https://127.0.0.1:#{port}}).to_stdout
+         .and output(%r{https://127.0.0.1:#{port}/bogus_test/puppet/v3/releases}).to_stderr
+      end
+    end
+  end
 end

data/spec/integration/application/resource_spec.rb

@@ -6,7 +6,41 @@ describe "puppet resource", unless: Puppet::Util::Platform.jruby? do
 
   let(:resource) { Puppet::Application[:resource] }
 
-  describe "when handling file and tidy types" do
+  context 'when given an invalid environment' do
+    before { Puppet[:environment] = 'badenv' }
+
+    it 'falls back to the default environment' do
+      Puppet[:log_level] = 'debug'
+
+      expect {
+        resource.run
+      }.to exit_with(1)
+       .and output(/Debug: Specified environment 'badenv' does not exist on the filesystem, defaulting to 'production'/).to_stdout
+       .and output(/Error: Could not run: You must specify the type to display/).to_stderr
+    end
+
+    it 'lists resources' do
+      resource.command_line.args = ['file', Puppet[:confdir]]
+
+      expect {
+        resource.run
+      }.to output(/file { '#{Puppet[:confdir]}':/).to_stdout
+    end
+
+    it 'lists types from the default environment' do
+      modulepath = File.join(Puppet[:codedir], 'modules', 'test', 'lib', 'puppet', 'type')
+      FileUtils.mkdir_p(modulepath)
+      File.write(File.join(modulepath, 'test.rb'), 'Puppet::Type.newtype(:test)')
+      resource.command_line.args = ['--types']
+
+      expect {
+        resource.run
+      }.to exit_with(0).and output(/test/).to_stdout
+    end
+  end
+
+
+  context 'when handling file and tidy types' do
     let!(:dir) { dir_containing('testdir', 'testfile' => 'contents') }
 
     it 'does not raise when generating file resources' do

data/spec/integration/application/ssl_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe "puppet ssl", unless: Puppet::Util::Platform.jruby? do
+  context "print" do
+    it 'translates custom oids to their long name' do
+      basedir = File.expand_path("#{__FILE__}/../../../fixtures/ssl")
+      # registering custom oids changes global state, so shell out
+      output =
+        %x{puppet ssl show \
+           --certname oid \
+           --localcacert #{basedir}/ca.pem \
+           --hostcrl #{basedir}/crl.pem \
+           --hostprivkey #{basedir}/oid-key.pem \
+           --hostcert #{basedir}/oid.pem \
+           --trusted_oid_mapping_file #{basedir}/trusted_oid_mapping.yaml 2>&1
+        }
+      expect(output).to match(/Long name:/)
+    end
+  end
+end

data/spec/integration/configurer_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Configurer do
       expect(Puppet::Transaction::Report.indirection).to receive(:save) do |report, x|
         expect(report.time).to be_a(Time)
         expect(report.logs.length).to be > 0
-      end
+      end.twice
 
       Puppet[:report] = true
 
@@ -60,7 +60,8 @@ describe Puppet::Configurer do
       expect(summary["time"]["last_run"]).to be_between(t1, t2)
     end
 
-    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true" do
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true and environment is valid" do
+      expect(@configurer).to receive(:valid_server_environment?).and_return(true)
       Puppet[:ignore_plugin_errors] = false
 
       Puppet[:use_cached_catalog] = false
@@ -74,6 +75,21 @@ describe Puppet::Configurer do
       expect(report.cached_catalog_status).to eq('on_failure')
     end
 
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true and environment is invalid" do
+      expect(@configurer).to receive(:valid_server_environment?).and_return(false)
+      Puppet[:ignore_plugin_errors] = false
+
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = true
+
+      report = Puppet::Transaction::Report.new
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_raise(Puppet::Error, 'Cannot compile remote catalog')
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
+
+      @configurer.run(pluginsync: true, report: report)
+      expect(report.cached_catalog_status).to eq('on_failure')
+    end
+
     describe 'resubmitting facts' do
       context 'when resubmit_facts is set to false' do
         it 'should not send data' do

data/spec/integration/environments/settings_interpolation_spec.rb

@@ -9,10 +9,6 @@ describe "interpolating $environment" do
   let(:confdir) { Puppet[:confdir] }
   let(:cmdline_args) { ['--confdir', confdir, '--vardir', Puppet[:vardir], '--hiera_config', Puppet[:hiera_config]] }
 
-  before(:each) do
-    FileUtils.mkdir_p(confdir)
-  end
-
   shared_examples_for "a setting that does not interpolate $environment" do
 
     before(:each) do

data/spec/integration/indirector/facts/facter_spec.rb

@@ -6,13 +6,14 @@ require 'puppet/indirector/facts/facter'
 describe Puppet::Node::Facts::Facter do
   include PuppetSpec::Files
   include PuppetSpec::Compiler
+  include PuppetSpec::Settings
 
   before :each do
     Puppet::Node::Facts.indirection.terminus_class = :facter
   end
 
   it "preserves case in fact values" do
-    Facter.add(:downcase_test) do
+    Puppet.runtime[:facter].add(:downcase_test) do
       setcode do
         "AaBbCc"
       end
@@ -33,9 +34,9 @@ describe Puppet::Node::Facts::Facter do
       FileUtils.mkdir_p(test_module)
 
       File.open(File.join(test_module, 'custom.rb'), 'wb') { |file| file.write(<<-EOF)}
-      Facter.add(:custom) do
+      Puppet.runtime[:facter].add(:custom) do
         setcode do
-          Facter.value('puppetversion')
+          Puppet.runtime[:facter].value('puppetversion')
         end
       end
       EOF
@@ -66,49 +67,102 @@ describe Puppet::Node::Facts::Facter do
     end
   end
 
-  it "adds the puppetversion fact" do
-    allow(Facter).to receive(:reset)
-
-    cat = compile_to_catalog('notify { $::puppetversion: }',
-                             Puppet::Node.indirection.find('foo'))
-    expect(cat.resource("Notify[#{Puppet.version.to_s}]")).to be
-  end
+  context "adding facts" do
+    it "adds the puppetversion fact" do
+      allow(Facter).to receive(:reset)
 
-  it "the agent_specified_environment fact is nil when not set" do
-    expect do
-      compile_to_catalog('notify { $::agent_specified_environment: }',
-                         Puppet::Node.indirection.find('foo'))
-    end.to raise_error(Puppet::PreformattedError)
-  end
-
-  it "adds the agent_specified_environment fact when set in puppet.conf" do
-    FileUtils.mkdir_p(Puppet[:confdir])
-    File.open(File.join(Puppet[:confdir], 'puppet.conf'), 'w') do |f|
-      f.puts("environment=bar")
+      cat = compile_to_catalog('notify { $::puppetversion: }',
+                               Puppet::Node.indirection.find('foo'))
+      expect(cat.resource("Notify[#{Puppet.version.to_s}]")).to be
     end
 
-    Puppet.initialize_settings
-    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+    context "when adding the agent_specified_environment fact" do
+      it "does not add the fact if the agent environment is not set" do
+        expect do
+          compile_to_catalog('notify { $::agent_specified_environment: }',
                              Puppet::Node.indirection.find('foo'))
-    expect(cat.resource("Notify[bar]")).to be
-  end
+        end.to raise_error(Puppet::PreformattedError)
+      end
 
-  it "adds the agent_specified_environment fact when set via command-line" do
-    Puppet.initialize_settings(['--environment', 'bar'])
-    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+      it "does not add the fact if the agent environment is set in sections other than agent or main" do
+        set_puppet_conf(Puppet[:confdir], <<~CONF)
+        [user]
+        environment=bar
+        CONF
+
+        Puppet.initialize_settings
+        expect do
+          compile_to_catalog('notify { $::agent_specified_environment: }',
                              Puppet::Node.indirection.find('foo'))
-    expect(cat.resource("Notify[bar]")).to be
-  end
+        end.to raise_error(Puppet::PreformattedError)
+      end
 
-  it "adds the agent_specified_environment fact, preferring cli, when set in puppet.conf and via command-line" do
-    FileUtils.mkdir_p(Puppet[:confdir])
-    File.open(File.join(Puppet[:confdir], 'puppet.conf'), 'w') do |f|
-      f.puts("environment=bar")
-    end
+      it "adds the agent_specified_environment fact when set in the agent section in puppet.conf" do
+        set_puppet_conf(Puppet[:confdir], <<~CONF)
+        [agent]
+        environment=bar
+        CONF
 
-    Puppet.initialize_settings(['--environment', 'baz'])
-    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                             Puppet::Node.indirection.find('foo'))
-    expect(cat.resource("Notify[baz]")).to be
+        Puppet.initialize_settings
+        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                                 Puppet::Node.indirection.find('foo'))
+        expect(cat.resource("Notify[bar]")).to be
+      end
+
+      it "prefers agent_specified_environment from main if set in section other than agent" do
+        set_puppet_conf(Puppet[:confdir], <<~CONF)
+        [main]
+        environment=baz
+
+        [user]
+        environment=bar
+        CONF
+
+        Puppet.initialize_settings
+        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                                 Puppet::Node.indirection.find('foo'))
+        expect(cat.resource("Notify[baz]")).to be
+      end
+
+      it "prefers agent_specified_environment from agent if set in multiple sections" do
+        set_puppet_conf(Puppet[:confdir], <<~CONF)
+        [main]
+        environment=baz
+
+        [agent]
+        environment=bar
+        CONF
+
+        Puppet.initialize_settings
+        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                                 Puppet::Node.indirection.find('foo'))
+        expect(cat.resource("Notify[bar]")).to be
+      end
+
+      it "adds the agent_specified_environment fact when set in puppet.conf" do
+        set_puppet_conf(Puppet[:confdir], 'environment=bar')
+
+        Puppet.initialize_settings
+        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                                 Puppet::Node.indirection.find('foo'))
+        expect(cat.resource("Notify[bar]")).to be
+      end
+
+      it "adds the agent_specified_environment fact when set via command-line" do
+        Puppet.initialize_settings(['--environment', 'bar'])
+        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                                 Puppet::Node.indirection.find('foo'))
+        expect(cat.resource("Notify[bar]")).to be
+      end
+
+      it "adds the agent_specified_environment fact, preferring cli, when set in puppet.conf and via command-line" do
+        set_puppet_conf(Puppet[:confdir], 'environment=bar')
+
+        Puppet.initialize_settings(['--environment', 'baz'])
+        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                                 Puppet::Node.indirection.find('foo'))
+        expect(cat.resource("Notify[baz]")).to be
+      end
+    end
   end
 end