puppet 6.25.0-x86-mingw32 → 6.27.0-x86-mingw32

data/spec/integration/http/client_spec.rb

@@ -77,6 +77,12 @@ 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],
@@ -88,6 +94,30 @@ 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

data/spec/integration/parser/pcore_resource_spec.rb

@@ -136,6 +136,16 @@ describe 'when pcore described resources types are in use' do
       expect(catalog.resource(:cap, "c")['message']).to eq('c works')
     end
 
+    it 'considers Pcore types to be builtin ' do
+      genface.types
+      catalog = compile_to_catalog(<<-MANIFEST)
+        test1 { 'a':
+          message => 'a works'
+        }
+      MANIFEST
+      expect(catalog.resource(:test1, "a").kind).to eq('compilable_type')
+    end
+
     it 'the validity of attribute names are checked' do
       genface.types
       expect do

data/spec/shared_contexts/l10n.rb

@@ -4,7 +4,11 @@ RSpec.shared_context('l10n') do |locale|
   before :all do
     @old_locale = Locale.current
     Locale.current = locale
+
+    @old_gettext_disabled = Puppet::GettextConfig.instance_variable_get(:@gettext_disabled)
+    Puppet::GettextConfig.instance_variable_set(:@gettext_disabled, false)
     Puppet::GettextConfig.setup_locale
+    Puppet::GettextConfig.create_default_text_domain
 
     # overwrite stubs with real implementation
     ::Object.send(:remove_method, :_)
@@ -17,6 +21,7 @@ RSpec.shared_context('l10n') do |locale|
   after :all do
     Locale.current = @old_locale
 
+    Puppet::GettextConfig.instance_variable_set(:@gettext_disabled, @old_gettext_disabled)
     # restore stubs
     load File.expand_path(File.join(__dir__, '../../lib/puppet/gettext/stubs.rb'))
   end

data/spec/unit/application/lookup_spec.rb

@@ -518,34 +518,155 @@ Searching for "a"
       end
 
       it 'receives extra facts in top scope' do
-        file_path = tmpdir('lookup_spec')
-        filename = File.join(file_path, "facts.yaml")
-        File.open(filename, "w+") { |f| f.write(<<-YAML.unindent) }
+        file_path = file_containing('facts.yaml', <<~CONTENT)
           ---
           cx: ' C from facts'
-          YAML
+        CONTENT
 
         lookup.options[:node] = node
-        lookup.options[:fact_file] = filename
+        lookup.options[:fact_file] = file_path
         lookup.options[:render_as] = :s
         allow(lookup.command_line).to receive(:args).and_return(['c'])
         expect(run_lookup(lookup)).to eql("This is C from facts")
       end
 
       it 'receives extra facts in the facts hash' do
-        file_path = tmpdir('lookup_spec')
-        filename = File.join(file_path, "facts.yaml")
-        File.open(filename, "w+") { |f| f.write(<<-YAML.unindent) }
+        file_path = file_containing('facts.yaml', <<~CONTENT)
           ---
           cx: ' G from facts'
-        YAML
+        CONTENT
 
         lookup.options[:node] = node
-        lookup.options[:fact_file] = filename
+        lookup.options[:fact_file] = file_path
         lookup.options[:render_as] = :s
         allow(lookup.command_line).to receive(:args).and_return(['g'])
         expect(run_lookup(lookup)).to eql("This is G from facts in facts hash")
       end
+
+      describe 'when retrieving given facts' do
+        before do
+          lookup.options[:node] = node
+          allow(lookup.command_line).to receive(:args).and_return(['g'])
+        end
+
+        it 'loads files with yaml extension as yaml on first try' do
+          file_path = file_containing('facts.yaml', <<~CONTENT)
+            ---
+            cx: ' G from facts'
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect(Puppet::Util::Yaml).to receive(:safe_load_file).with(file_path, []).and_call_original
+          run_lookup(lookup)
+        end
+
+        it 'loads files with yml extension as yaml on first try' do
+          file_path = file_containing('facts.yml', <<~CONTENT)
+            ---
+            cx: ' G from facts'
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect(Puppet::Util::Yaml).to receive(:safe_load_file).with(file_path, []).and_call_original
+          run_lookup(lookup)
+        end
+
+        it 'loads files with json extension as json on first try' do
+          file_path = file_containing('facts.json', <<~CONTENT)
+            {
+              "cx": " G from facts"
+            }
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect(Puppet::Util::Json).to receive(:load_file).with(file_path, {}).and_call_original
+          run_lookup(lookup)
+        end
+
+        it 'detects file format accordingly even with random file extension' do
+          file_path = file_containing('facts.txt', <<~CONTENT)
+            {
+              "cx": " G from facts"
+            }
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect(Puppet::Util::Json).to receive(:load_file_if_valid).with(file_path).and_call_original
+          expect(Puppet::Util::Yaml).not_to receive(:safe_load_file_if_valid).with(file_path)
+          run_lookup(lookup)
+        end
+
+        it 'detects file without extension as json due to valid contents' do
+          file_path = file_containing('facts', <<~CONTENT)
+            {
+              "cx": " G from facts"
+            }
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect(Puppet::Util::Json).to receive(:load_file_if_valid).with(file_path).and_call_original
+          expect(Puppet::Util::Yaml).not_to receive(:safe_load_file_if_valid).with(file_path)
+          run_lookup(lookup)
+        end
+
+        it 'detects file without extension as yaml due to valid contents' do
+          file_path = file_containing('facts', <<~CONTENT)
+            ---
+            cx: ' G from facts'
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect(Puppet::Util::Json.load_file_if_valid(file_path)).to be_nil
+          expect(Puppet::Util::Yaml).to receive(:safe_load_file_if_valid).with(file_path).and_call_original
+          run_lookup(lookup)
+        end
+
+        it 'raises error due to invalid contents' do
+          file_path = file_containing('facts.yml', <<~CONTENT)
+            INVALID CONTENT
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect {
+            lookup.run_command
+          }.to raise_error(/Incorrectly formatted data in .+ given via the --facts flag \(only accepts yaml and json files\)/)
+        end
+
+        it "fails when a node doesn't have facts" do
+          lookup.options[:node] = "bad.node"
+          allow(lookup.command_line).to receive(:args).and_return(['c'])
+
+          expected_error = "No facts available for target node: #{lookup.options[:node]}"
+          expect { lookup.run_command }.to raise_error(RuntimeError, expected_error)
+        end
+
+        it 'raises error due to missing trusted information facts in --facts file' do
+          file_path = file_containing('facts.yaml', <<~CONTENT)
+            ---
+            fqdn: some.fqdn.com
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect {
+            lookup.run_command
+          }.to raise_error(/When overriding any of the hostname,domain,fqdn,clientcert facts with #{file_path} given via the --facts flag, they must all be overridden./)
+        end
+
+        it 'does not fail when all trusted information facts are provided via --facts file' do
+          file_path = file_containing('facts.yaml', <<~CONTENT)
+            ---
+            fqdn: some.fqdn.com
+            hostname: some.hostname
+            domain: some.domain
+            clientcert: some.clientcert
+          CONTENT
+          lookup.options[:fact_file] = file_path
+
+          expect {
+            lookup.run_command
+          }.to exit_with(0)
+        end
+      end
     end
 
     context 'using a puppet function as data provider' do

data/spec/unit/concurrent/thread_local_singleton_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'puppet/concurrent/thread_local_singleton'
+
+class PuppetSpec::Singleton
+  extend Puppet::Concurrent::ThreadLocalSingleton
+end
+
+# Use the `equal?` matcher to ensure we get the same object
+describe Puppet::Concurrent::ThreadLocalSingleton do
+  it 'returns the same object for a single thread' do
+    expect(PuppetSpec::Singleton.singleton).to equal(PuppetSpec::Singleton.singleton)
+  end
+
+  it 'is not inherited for a newly created thread' do
+    main_thread_local = PuppetSpec::Singleton.singleton
+    Thread.new do
+      expect(main_thread_local).to_not equal(PuppetSpec::Singleton.singleton)
+    end.join
+  end
+
+  it 'does not leak outside a thread' do
+    thread_local = nil
+    Thread.new do
+      thread_local = PuppetSpec::Singleton.singleton
+    end.join
+    expect(thread_local).to_not equal(PuppetSpec::Singleton.singleton)
+  end
+
+  it 'is different for each thread' do
+    locals = []
+    Thread.new do
+      locals << PuppetSpec::Singleton.singleton
+    end.join
+    Thread.new do
+      locals << PuppetSpec::Singleton.singleton
+    end.join
+    expect(locals.first).to_not equal(locals.last)
+  end
+end

data/spec/unit/configurer_spec.rb

@@ -2,14 +2,24 @@ require 'spec_helper'
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
+  include PuppetSpec::Files
+
   before do
     Puppet[:server] = "puppetmaster"
     Puppet[:report] = true
 
     catalog.add_resource(resource)
-    allow_any_instance_of(described_class).to(
-      receive(:valid_server_environment?).and_return(true)
-    )
+
+    Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', <<~SUMMARY)
+    ---
+    version:
+      config: 1624882680
+      puppet: #{Puppet.version}
+    application:
+      initial_environment: #{Puppet[:environment]}
+      converged_environment: #{Puppet[:environment]}
+      run_mode: agent
+    SUMMARY
   end
 
   let(:node_name) { Puppet[:node_name_value] }
@@ -65,10 +75,44 @@ describe Puppet::Configurer do
     end
   end
 
+  describe "when executing a catalog run without stubbing valid_server_environment?" do
+    before do
+      Puppet::Resource::Catalog.indirection.terminus_class = :rest
+      allow(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(catalog)
+    end
+
+    it 'skips initial plugin sync if environment is not found and no strict_environment_mode' do
+      body = "{\"message\":\"Not Found: Could not find environment 'fasdfad'\",\"issue_kind\":\"RUNTIME_ERROR\"}"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/plugins?}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+
+      configurer.run(:pluginsync => true)
+
+      expect(@logs).to include(an_object_having_attributes(level: :notice, message: %r{Environment 'production' not found on server, skipping initial pluginsync.}))
+      expect(@logs).to include(an_object_having_attributes(level: :notice, message: /Applied catalog in .* seconds/))
+    end
+
+    it 'if strict_environment_mode is set and environment is not found, aborts the puppet run' do
+      Puppet[:strict_environment_mode] = true
+      body = "{\"message\":\"Not Found: Could not find environment 'fasdfad'\",\"issue_kind\":\"RUNTIME_ERROR\"}"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/plugins?}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+
+      configurer.run(:pluginsync => true)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: %r{Failed to apply catalog: Environment 'production' not found on server, aborting run.}))
+    end
+  end
+
   describe "when executing a catalog run" do
     before do
       Puppet::Resource::Catalog.indirection.terminus_class = :rest
       allow(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(catalog)
+      allow_any_instance_of(described_class).to(
+        receive(:valid_server_environment?).and_return(true)
+      )
     end
 
     it "downloads plugins when told" do
@@ -742,7 +786,7 @@ describe Puppet::Configurer do
           expect(configurer.run).to be_nil
         end
 
-        it "should proceed with the cached catalog if its environment matchs the local environment" do
+        it "should proceed with the cached catalog if its environment matches the local environment" do
           expects_cached_catalog_only(catalog)
 
           expect(configurer.run).to eq(0)
@@ -1099,7 +1143,6 @@ describe Puppet::Configurer do
   end
 
   describe "when selecting an environment" do
-    include PuppetSpec::Files
     include PuppetSpec::Settings
 
     describe "when the last used environment is available" do
@@ -1118,118 +1161,199 @@ describe Puppet::Configurer do
         SUMMARY
       end
 
-      it "prefers the environment set via cli" do
-        Puppet.settings.handlearg('--environment', 'usethis')
-        configurer.run
-
-        expect(configurer.environment).to eq('usethis')
-      end
+      describe "when the use_last_environment is set to true" do
+        before do
+          expect(Puppet::Node.indirection).not_to receive(:find)
+          .with(anything, hash_including(:ignore_cache => true, :fail_on_404 => true))
+        end
 
-      it "prefers the environment set via config" do
-        FileUtils.mkdir_p(Puppet[:confdir])
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [main]
-        environment = usethis
-        CONF
+        it "prefers the environment set via cli" do
+          Puppet.settings.handlearg('--environment', 'usethis')
+          configurer.run
 
-        Puppet.initialize_settings
-        configurer.run
+          expect(configurer.environment).to eq('usethis')
+        end
 
-        expect(configurer.environment).to eq('usethis')
-      end
+        it "prefers the environment set via lastrunfile over config" do
+          FileUtils.mkdir_p(Puppet[:confdir])
+          set_puppet_conf(Puppet[:confdir], <<~CONF)
+          [main]
+          environment = usethis
+          lastrunfile = #{Puppet[:lastrunfile]}
+          CONF
 
-      it "uses environment from Puppet[:environment] if given a catalog" do
-        configurer.run(catalog: catalog)
+          Puppet.initialize_settings
+          configurer.run
 
-        expect(configurer.environment).to eq(Puppet[:environment])
-      end
+          expect(configurer.environment).to eq(last_server_specified_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
+        it "uses the environment from Puppet[:environment] if given a catalog" do
+          configurer.run(catalog: catalog)
 
-        expect(configurer.environment).to eq(Puppet[:environment])
-      end
+          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
+        it "uses the 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(last_server_specified_environment)
+          expect(configurer.environment).to eq(Puppet[:environment])
         end
 
-        it "pushes the converged environment found in lastrunfile over the existing context" do
-          initial_env = Puppet::Node::Environment.remote('production')
-          Puppet.push_context(
-            current_environment: initial_env,
-            loaders: Puppet::Pops::Loaders.new(initial_env, true))
+        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 "pushes the converged environment found in lastrunfile over the existing context" do
+            initial_env = Puppet::Node::Environment.remote('production')
+            Puppet.push_context(
+              current_environment: initial_env,
+              loaders: Puppet::Pops::Loaders.new(initial_env, true))
+
+            expect(Puppet).to receive(:push_context).with(
+              hash_including(:current_environment, :loaders),
+              "Local node environment #{last_server_specified_environment} for configurer transaction"
+            ).once.and_call_original
+
+            configurer.run
+          end
+
+          it "uses the 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 the 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
+        end
+      end
+
+      describe "when the use_last_environment setting is set to false" do
+        let(:node_environment) { Puppet::Node::Environment.remote(:salam) }
+        let(:node) { Puppet::Node.new(Puppet[:node_name_value]) }
 
-          expect(Puppet).to receive(:push_context).with(
-            hash_including(:current_environment, :loaders),
-            "Local node environment #{last_server_specified_environment} for configurer transaction"
-          ).once.and_call_original
+        before do
+          Puppet[:use_last_environment] = false
+          node.environment = node_environment
+
+          allow(Puppet::Node.indirection).to receive(:find)
+          allow(Puppet::Node.indirection).to receive(:find)
+            .with(anything, hash_including(:ignore_cache => true, :fail_on_404 => true))
+            .and_return(node)
+        end
+
+        it "does a node request" do
+          expect(Puppet::Node.indirection).to receive(:find)
+          .with(anything, hash_including(:ignore_cache => true, :fail_on_404 => true))
 
           configurer.run
         end
 
-        it "uses environment from Puppet[:environment] if strict_environment_mode is set" do
-          Puppet[:strict_environment_mode] = true
+        it "uses the node environment from the node request" do
           configurer.run
 
-          expect(configurer.environment).to eq(Puppet[:environment])
+          expect(configurer.environment).to eq(node_environment.name.to_s)
         end
+      end
+    end
 
-        it "uses environment from Puppet[:environment] if initial_environment is the same as converged_environment" do
+    describe "when the last used environment is not available" do
+      describe "when the node request succeeds" do
+        let(:node_environment) { Puppet::Node::Environment.remote(:salam) }
+        let(:node) { Puppet::Node.new(Puppet[:node_name_value]) }
+        let(:last_server_specified_environment) { 'development' }
+
+        before do
+          node.environment = node_environment
+
+          allow(Puppet::Node.indirection).to receive(:find)
+          allow(Puppet::Node.indirection).to receive(:find)
+            .with(anything, hash_including(:ignore_cache => true, :fail_on_404 => true))
+            .and_return(node)
+        end
+
+        it "uses the environment from the node request 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: development
-            converged_environment: development
-            run_mode: agent
+            ---
+            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])
+          expect(configurer.environment).to eq(node_environment.name.to_s)
         end
 
-        it "uses environment from Puppet[:environment] if the run mode doesn't match" do
+        it "uses the environment from the node request if lastrunfile does not contain the expected keys" 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
+            ---
+            version:
+              config: 1624882680
+              puppet: 6.24.0
           SUMMARY
           configurer.run
 
-          expect(configurer.environment).to eq(Puppet[:environment])
+          expect(configurer.environment).to eq(node_environment.name.to_s)
         end
 
-        it "uses environment from Puppet[:environment] if lastrunfile is invalid YAML" do
+        it "uses the environment from the node request if lastrunfile is invalid YAML" do
           Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', <<~SUMMARY)
-          Key: 'this is my very very very ' +
-               'long string'
+            Key: 'this is my very very very ' +
+                 'long string'
           SUMMARY
           configurer.run
 
-          expect(configurer.environment).to eq(Puppet[:environment])
+          expect(configurer.environment).to eq(node_environment.name.to_s)
         end
 
-        it "uses environment from Puppet[:environment] if lastrunfile exists but is empty" do
+        it "uses the environment from the node request if lastrunfile exists but is empty" do
           Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', '')
           configurer.run
 
-          expect(configurer.environment).to eq(Puppet[:environment])
+          expect(configurer.environment).to eq(node_environment.name.to_s)
+        end
+
+        it "uses the environment from the node request if the last used one cannot be found" do
+          Puppet[:lastrunfile] = tmpfile('last_run_summary.yaml')
+          configurer.run
+
+          expect(configurer.environment).to eq(node_environment.name.to_s)
+        end
+      end
+
+      describe "when the node request fails" do
+        before do
+          allow(Puppet::Node.indirection).to receive(:find).and_call_original
+          allow(Puppet::Node.indirection).to receive(:find)
+            .with(anything, hash_including(:ignore_cache => true, :fail_on_404 => true))
+            .and_raise(Puppet::Error)
         end
 
-        it "uses environment from Puppet[:environment] if the last used one cannot be found" do
+        it "uses the environment from Puppet[:environment] if the last used one cannot be found" do
           Puppet[:lastrunfile] = tmpfile('last_run_summary.yaml')
           configurer.run