puppet 6.27.0 → 7.0.0

data/spec/integration/application/lookup_spec.rb

@@ -7,7 +7,6 @@ describe 'lookup' do
   include PuppetSpec::Files
 
   context 'with an environment' do
-    let(:fqdn) { Puppet[:certname] }
     let(:env_name) { 'spec' }
     let(:env_dir) { tmpdir('environments') }
     let(:environment_files) do
@@ -43,117 +42,94 @@ describe 'lookup' do
     end
 
     let(:app) { Puppet::Application[:lookup] }
-    let(:facts) { Puppet::Node::Facts.new("facts", {'my_fact' => 'my_fact_value'}) }
-    let(:cert) { pem_content('oid.pem') }
+    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(:node) { Puppet::Node.new('testnode', :facts => facts) }
     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)
-
-      Puppet[:environment] = env_name
-      Puppet[:environmentpath] = populated_env_dir
-
-      http = Puppet::HTTP::Client.new(ssl_context: Puppet::SSL::SSLProvider.new.create_insecure_context)
-      Puppet.runtime[:http] = http
-    end
-
-    def expect_lookup_with_output(exitcode, out)
-      expect { app.run }.to exit_with(exitcode).and output(out).to_stdout
+    def lookup(key, options = {}, explain = false)
+      key = [key] unless key.is_a?(Array)
+      allow(app.command_line).to receive(:args).and_return(key)
+      if explain
+        app.options[:explain] = true
+        app.options[:render_as] = :s
+      else
+        app.options[:render_as] = :json
+      end
+      options.each_pair { |k, v| app.options[k] = v }
+      capture = StringIO.new
+      saved_stdout = $stdout
+      begin
+        $stdout = capture
+        expect { app.run_command }.to exit_with(0)
+      ensure
+        $stdout = saved_stdout
+      end
+      out = capture.string.strip
+      if explain
+        out
+      else
+        out.empty? ? nil : JSON.parse("[#{out}]")[0]
+      end
     end
 
-    it 'finds data in the environment' do
-      app.command_line.args << 'a'
-      expect_lookup_with_output(0, /value a/)
+    def explain(key, options = {})
+      lookup(key, options, true)
     end
 
-    it "resolves hiera data using a top-level node parameter" do
-      File.write(File.join(env_dir, env_name, 'hiera.yaml'), <<~YAML)
-        ---
-        version: 5
-        hierarchy:
-          - name: "Per Node"
-            data_hash: yaml_data
-            path: "%{my_fact}.yaml"
-      YAML
-
-      File.write(File.join(env_dir, env_name, 'data', "my_fact_value.yaml"), <<~YAML)
-        ---
-        a: value from per node data
-      YAML
-
-      app.command_line.args << 'a'
-      expect_lookup_with_output(0, /--- value from per node data/)
+    around(:each) do |example|
+      Puppet.override(:environments => environments, :current_environment => env) do
+        example.run
+      end
     end
 
-    it 'loads trusted information from the node certificate' do
-      Puppet.settings[:node_terminus] = 'exec'
-      expect_any_instance_of(Puppet::Node::Exec).to receive(:find) do |args|
-        info = Puppet.lookup(:trusted_information)
-        expect(info.certname).to eq(fqdn)
-        expect(info.extensions).to eq({ "1.3.6.1.4.1.34380.1.2.1.1" => "somevalue" })
-      end.and_return(node)
-
-      app.command_line.args << 'a' << '--compile'
-      expect_lookup_with_output(0, /--- value a/)
+    it 'finds data in the environment' do
+      expect(lookup('a')).to eql('value a')
     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)
-
-      app.command_line.args << 'a'
-      expect_lookup_with_output(0, /--- value a/)
+      lookup('a')
     end
 
-    describe 'when using --node' do
-      let(:fqdn) { 'random_node' }
-
-      it 'skips loading of external facts' do
-        app.command_line.args << 'a' << '--node' << fqdn
-
-        expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(facts)
-        expect(Facter).to receive(:load_external).twice.with(false)
-        expect(Facter).to receive(:load_external).twice.with(true)
-        expect_lookup_with_output(0, /--- value 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')
     end
 
     context 'uses node_terminus' do
       require 'puppet/indirector/node/exec'
       require 'puppet/indirector/node/plain'
 
-      let(:node) { Puppet::Node.new('testnode', :facts => facts) }
+      let(:node) { Puppet::Node.new('testnode', :environment => env) }
 
       it ':plain without --compile' do
         Puppet.settings[:node_terminus] = 'exec'
         expect_any_instance_of(Puppet::Node::Plain).to receive(:find).and_return(node)
         expect_any_instance_of(Puppet::Node::Exec).not_to receive(:find)
-
-        app.command_line.args << 'a'
-        expect_lookup_with_output(0, /--- value a/)
+        expect(lookup('a')).to eql('value a')
       end
 
       it 'configured in Puppet settings with --compile' do
         Puppet.settings[:node_terminus] = 'exec'
         expect_any_instance_of(Puppet::Node::Plain).not_to receive(:find)
         expect_any_instance_of(Puppet::Node::Exec).to receive(:find).and_return(node)
-
-        app.command_line.args << 'a' << '--compile'
-        expect_lookup_with_output(0, /--- value a/)
+        expect(lookup('a', :compile => true)).to eql('value a')
       end
     end
 
     context 'configured with the wrong environment' do
+      let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
       it 'does not find data in non-existing environment' do
-        Puppet[:environment] = 'doesntexist'
-        app.command_line.args << 'a'
-        expect { app.run }.to raise_error(Puppet::Environments::EnvironmentNotFound, /Could not find a directory environment named 'doesntexist'/)
+        Puppet.override(:environments => environments, :current_environment => 'someother') do
+          expect(lookup('a', {}, true)).to match(/did not find a value for the name 'a'/)
+        end
       end
     end
 
@@ -198,22 +174,15 @@ describe 'lookup' do
       end
 
       it 'finds data in the module' do
-        app.command_line.args << 'mod_a::b'
-        expect_lookup_with_output(0, /value mod_a::b \(from mod_a\)/)
+        expect(lookup('mod_a::b')).to eql('value mod_a::b (from mod_a)')
       end
 
       it 'finds quoted keys in the module' do
-        app.command_line.args << "'mod_a::a.quoted.key'"
-        expect_lookup_with_output(0, /value mod_a::a.quoted.key \(from mod_a\)/)
+        expect(lookup('"mod_a::a.quoted.key"')).to eql('value mod_a::a.quoted.key (from mod_a)')
       end
 
       it 'merges hashes from environment and module when merge strategy hash is used' do
-        app.command_line.args << 'mod_a::hash_a' << '--merge' << 'hash'
-        expect_lookup_with_output(0, <<~END)
-          ---
-          a: value mod_a::hash_a.a (from environment)
-          b: value mod_a::hash_a.b (from mod_a)
-        END
+        expect(lookup('mod_a::hash_a', :merge => 'hash')).to eql({'a' => 'value mod_a::hash_a.a (from environment)', 'b' => 'value mod_a::hash_a.b (from mod_a)'})
       end
     end
   end

data/spec/integration/application/module_spec.rb

@@ -65,25 +65,4 @@ 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/plugin_spec.rb

@@ -2,14 +2,15 @@ require 'spec_helper'
 require 'puppet/face'
 require 'puppet_spec/puppetserver'
 
-describe "puppet plugin", unless: Puppet::Util::Platform.jruby? do
+describe "puppet plugin" do
   include_context "https client"
 
   let(:server) { PuppetSpec::Puppetserver.new }
   let(:plugin) { Puppet::Application[:plugin] }
   let(: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}]" }
 
-  it "downloads from plugins, pluginsfacts and locales mounts" do
+  it "downloads from plugins, pluginsfacts and locales mounts when i18n is enabled" do
+    Puppet[:disable_i18n] = false
     current_version_handler = -> (req, res) {
       res['X-Puppet-Version'] = Puppet.version
       res['Content-Type'] = 'application/json'
@@ -28,6 +29,27 @@ describe "puppet plugin", unless: Puppet::Util::Platform.jruby? do
     end
   end
 
+  it "downloads from plugins, pluginsfacts but no locales mounts when i18n is disabled" do
+    Puppet[:disable_i18n] = true
+
+    current_version_handler = -> (req, res) {
+      res['X-Puppet-Version'] = Puppet.version
+      res['Content-Type'] = 'application/json'
+      res.body = response_body
+    }
+
+    server.start_server(mounts: {file_metadatas: current_version_handler}) do |port|
+      Puppet[:serverport] = port
+      expect {
+        plugin.command_line.args << 'download'
+        plugin.run
+      }.to exit_with(0)
+       .and output(matching(
+         "Downloaded these plugins: #{Regexp.escape(Puppet[:pluginfactdest])}, #{Regexp.escape(Puppet[:plugindest])}"
+       )).to_stdout
+    end
+  end
+
   it "downloads from plugins and pluginsfacts from older puppetservers" do
     no_locales_handler = -> (req, res) {
       res['X-Puppet-Version'] = '5.3.3' # locales mount was added in 5.3.4

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.twice
+      end
 
       Puppet[:report] = true
 
@@ -60,8 +60,7 @@ 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 and environment is valid" do
-      expect(@configurer).to receive(:valid_server_environment?).and_return(true)
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true" do
       Puppet[:ignore_plugin_errors] = false
 
       Puppet[:use_cached_catalog] = false
@@ -75,21 +74,6 @@ 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/defaults_spec.rb

@@ -36,6 +36,13 @@ describe "Puppet defaults" do
     end
   end
 
+  describe "when setting the :serverport" do
+    it "should also set the :masterport to the same value" do
+      Puppet.settings[:serverport] = 9000
+      expect(Puppet.settings[:masterport]).to eq(9000)
+    end
+  end
+
   describe "when setting the :factpath" do
     it "should add the :factpath to Facter's search paths" do
       expect(Facter).to receive(:search).with("/my/fact/path")
@@ -152,6 +159,10 @@ describe "Puppet defaults" do
     expect(Puppet.settings.value(:preferred_serialization_format)).to eq("json")
   end
 
+  it "should default to true the disable_i18n setting" do
+    expect(Puppet.settings.value(:disable_i18n)).to eq(true)
+  end
+
   it "should have a setting for determining the configuration version and should default to an empty string" do
     expect(Puppet.settings[:config_version]).to eq("")
   end
@@ -164,18 +175,18 @@ describe "Puppet defaults" do
 
     it "should use the default serverport value when report port is unspecified" do
       Puppet.settings[:serverport] = "1234"
-      expect(Puppet.settings[:report_port]).to eq("1234")
+      expect(Puppet.settings[:report_port]).to eq(1234)
     end
 
     it "should use the default masterport value when report port is unspecified" do
       Puppet.settings[:masterport] = "1234"
-      expect(Puppet.settings[:report_port]).to eq("1234")
+      expect(Puppet.settings[:report_port]).to eq(1234)
     end
 
     it "should use report_port when set" do
       Puppet.settings[:serverport] = "1234"
       Puppet.settings[:report_port] = "5678"
-      expect(Puppet.settings[:report_port]).to eq("5678")
+      expect(Puppet.settings[:report_port]).to eq(5678)
     end
   end
 

data/spec/integration/environments/settings_interpolation_spec.rb

@@ -9,6 +9,10 @@ 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/http/client_spec.rb

@@ -77,12 +77,6 @@ describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
       }
     }
 
-    let(:systemstore) do
-      res = tmpfile('systemstore')
-      File.write(res, https_server.ca_cert)
-      res
-    end
-
     it "mutually authenticates the connection" do
       client_context = ssl_provider.create_context(
         cacerts: [https_server.ca_cert], crls: [https_server.ca_crl],
@@ -94,30 +88,6 @@ describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
         expect(res).to be_success
       end
     end
-
-    it "connects when the server's CA is in the system store and the connection is mutually authenticated using create_context" do
-      Puppet::Util.withenv("SSL_CERT_FILE" => systemstore) do
-        client_context = ssl_provider.create_context(
-          cacerts: [https_server.ca_cert], crls: [https_server.ca_crl],
-          client_cert: https_server.server_cert, private_key: https_server.server_key,
-          revocation: false, include_system_store: true
-        )
-        https_server.start_server(ctx_proc: ctx_proc) do |port|
-          res = client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: client_context})
-          expect(res).to be_success
-        end
-      end
-    end
-
-    it "connects when the server's CA is in the system store and the connection is mutually authenticated uning load_context" do
-      Puppet::Util.withenv("SSL_CERT_FILE" => systemstore) do
-        client_context = ssl_provider.load_context(revocation: false, include_system_store: true)
-        https_server.start_server(ctx_proc: ctx_proc) do |port|
-          res = client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: client_context})
-          expect(res).to be_success
-        end
-      end
-    end
   end
 
   context "with a system trust store" do
@@ -181,16 +151,4 @@ describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
       end
     end
   end
-
-  context 'ciphersuites' do
-    it "does not connect when using an SSLv3 ciphersuite", :if => Puppet::Util::Package.versioncmp(OpenSSL::OPENSSL_LIBRARY_VERSION.split[1], '1.1.1e') > 0 do
-      Puppet[:ciphers] = "DES-CBC3-SHA"
-
-      https_server.start_server do |port|
-        expect {
-          client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: root_context})
-        }.to raise_error(Puppet::HTTP::ConnectionError, /no cipher match|sslv3 alert handshake failure/)
-      end
-    end
-  end
 end

data/spec/integration/indirector/direct_file_server_spec.rb

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

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

@@ -6,14 +6,13 @@ 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
-    Puppet.runtime[:facter].add(:downcase_test) do
+    Facter.add(:downcase_test) do
       setcode do
         "AaBbCc"
       end
@@ -34,9 +33,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)}
-      Puppet.runtime[:facter].add(:custom) do
+      Facter.add(:custom) do
         setcode do
-          Puppet.runtime[:facter].value('puppetversion')
+          Facter.value('puppetversion')
         end
       end
       EOF
@@ -67,102 +66,49 @@ describe Puppet::Node::Facts::Facter do
     end
   end
 
-  context "adding facts" do
-    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 "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'))
-        end.to raise_error(Puppet::PreformattedError)
-      end
-
-      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
+  it "adds the puppetversion fact" do
+    allow(Facter).to receive(:reset)
 
-        Puppet.initialize_settings
-        expect do
-          compile_to_catalog('notify { $::agent_specified_environment: }',
+    cat = compile_to_catalog('notify { $::puppetversion: }',
                              Puppet::Node.indirection.find('foo'))
-        end.to raise_error(Puppet::PreformattedError)
-      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
-        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
+    expect(cat.resource("Notify[#{Puppet.version.to_s}]")).to be
+  end
 
-      it "adds the agent_specified_environment fact when set in puppet.conf" do
-        set_puppet_conf(Puppet[:confdir], 'environment=bar')
+  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
 
-        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
+    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 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
+    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, preferring cli, when set in puppet.conf and via command-line" do
-        set_puppet_conf(Puppet[:confdir], 'environment=bar')
+  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
 
-        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
+  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
+
+    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