puppet 7.12.1 → 7.15.0

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

@@ -9,9 +9,6 @@ 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)
-    )
 
     Puppet[:lastrunfile] = file_containing('last_run_summary.yaml', <<~SUMMARY)
     ---
@@ -78,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
@@ -1251,88 +1282,120 @@ describe Puppet::Configurer do
           converged_environment: #{last_server_specified_environment}
           run_mode: agent
         SUMMARY
+      end
 
-        expect(Puppet::Node.indirection).not_to receive(:find)
+      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
+        end
 
-      it "prefers the environment set via cli" do
-        Puppet.settings.handlearg('--environment', 'usethis')
-        configurer.run
+        it "prefers the environment set via cli" do
+          Puppet.settings.handlearg('--environment', 'usethis')
+          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 "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
 
-        Puppet.initialize_settings
-        configurer.run
+          Puppet.initialize_settings
+          configurer.run
 
-        expect(configurer.environment).to eq(last_server_specified_environment)
-      end
+          expect(configurer.environment).to eq(last_server_specified_environment)
+        end
 
-      it "uses the environment from Puppet[:environment] if given a catalog" do
-        configurer.run(catalog: catalog)
+        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
 
-      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
+        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(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
-          configurer.run
+        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)
+            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
 
-        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 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
 
-          configurer.run
+          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 Puppet[:environment] if strict_environment_mode is set" do
-          Puppet[:strict_environment_mode] = true
-          configurer.run
+        it "does a node request" do
+          expect(Puppet::Node.indirection).to receive(:find)
+          .with(anything, hash_including(:ignore_cache => true, :fail_on_404 => true))
 
-          expect(configurer.environment).to eq(Puppet[:environment])
+          configurer.run
         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
+        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

data/spec/unit/confiner_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 require 'puppet/confiner'
 
 describe Puppet::Confiner do
+  let(:coll) { Puppet::ConfineCollection.new('') }
+
   before do
     @object = Object.new
     @object.extend(Puppet::Confiner)
@@ -21,7 +23,6 @@ describe Puppet::Confiner do
   end
 
   it "should delegate its confine method to its confine collection" do
-    coll = double('collection')
     allow(@object).to receive(:confine_collection).and_return(coll)
     expect(coll).to receive(:confine).with(:foo => :bar, :bee => :baz)
     @object.confine(:foo => :bar, :bee => :baz)
@@ -39,22 +40,21 @@ describe Puppet::Confiner do
 
   describe "when testing suitability" do
     before do
-      @coll = double('collection')
-      allow(@object).to receive(:confine_collection).and_return(@coll)
+      allow(@object).to receive(:confine_collection).and_return(coll)
     end
 
     it "should return true if the confine collection is valid" do
-      expect(@coll).to receive(:valid?).and_return(true)
+      expect(coll).to receive(:valid?).and_return(true)
       expect(@object).to be_suitable
     end
 
     it "should return false if the confine collection is invalid" do
-      expect(@coll).to receive(:valid?).and_return(false)
+      expect(coll).to receive(:valid?).and_return(false)
       expect(@object).not_to be_suitable
     end
 
     it "should return the summary of the confine collection if a long result is asked for" do
-      expect(@coll).to receive(:summary).and_return("myresult")
+      expect(coll).to receive(:summary).and_return("myresult")
       expect(@object.suitable?(false)).to eq("myresult")
     end
   end

data/spec/unit/face/generate_spec.rb

@@ -221,6 +221,70 @@ describe Puppet::Face[:generate, :current] do
       end
 
     end
+
+    context "in an environment with a faulty type" do
+      let(:dir) do
+        dir_containing('environments', { 'testing_generate2' => {
+          'environment.conf' => "modulepath = modules",
+          'manifests' => { 'site.pp' => "" },
+          'modules' => {
+            'm3' => {
+              'lib' => { 'puppet' => { 'type' => {
+                'test3.rb' => <<-EOF
+                module Puppet
+                Type.newtype(:test3) do
+                  @doc = "Docs for resource"
+                  def self.title_patterns
+                    identity = lambda {|x| x}
+                    [
+                      [
+                      /^(.*)_(.*)$/,
+                        [
+                          [:name, identity ]
+                        ]
+                      ]
+                    ]
+                  end
+                  newproperty(:message) do
+                    desc "Docs for 'message' property"
+                  end
+                  newparam(:name) do
+                    desc "Docs for 'name' parameter"
+                    isnamevar
+                  end
+                end; end
+                EOF
+               } }
+            }
+          }
+        }}})
+      end
+
+      let(:modulepath) do
+        File.join(dir, 'testing_generate2', 'modules')
+      end
+
+      let(:m3) do
+        File.join(modulepath, 'm3')
+      end
+
+      around(:each) do |example|
+        Puppet.settings.initialize_global_settings
+        Puppet[:manifest] = ''
+        loader = Puppet::Environments::Directories.new(dir, [])
+        Puppet.override(:environments => loader) do
+          Puppet.override(:current_environment => loader.get('testing_generate2')) do
+            example.run
+          end
+        end
+      end
+
+      it 'fails when using procs for title patterns' do
+        expect {
+          genface.types(:format => 'pcore')
+        }.to exit_with(1)
+      end
+    end
   end
 
   def from_an_interactive_terminal

data/spec/unit/file_system/uniquefile_spec.rb

@@ -80,7 +80,7 @@ describe Puppet::FileSystem::Uniquefile do
     lock = File.join(dir, 'path', 'to', 'lock')
 
     expect {
-      Puppet::FileSystem::Uniquefile.open_tmp(lock) { |tmp| }
+      Puppet::FileSystem::Uniquefile.new('foo', lock) { |tmp| }
     }.to raise_error(Errno::ENOENT, %r{No such file or directory - A directory component in .* does not exist or is a dangling symbolic link})
   end
 
@@ -102,6 +102,12 @@ describe Puppet::FileSystem::Uniquefile do
     expect(filename).to eq(temp_rune_utf8)
   end
 
+  it "preserves tilde characters" do
+    Puppet::FileSystem::Uniquefile.open_tmp('~foo') do |file|
+      expect(File.basename(file.path)).to start_with('~foo')
+    end
+  end
+
   context "Ruby 1.9.3 Tempfile tests" do
     # the remaining tests in this file are ported directly from the ruby 1.9.3 source,
     # since most of this file was ported from there

data/spec/unit/file_system_spec.rb

@@ -984,11 +984,12 @@ describe "Puppet::FileSystem" do
         end
 
         it 'preserves file ownership' do
-          allow(Puppet::FileSystem).to receive(:lstat)
-            .with(Puppet::FileSystem.pathname(dest))
-            .and_return(double(uid: 1, gid: 2))
+          FileUtils.touch(dest)
+          allow(File).to receive(:lstat).and_call_original
+          allow(File).to receive(:lstat).with(Pathname.new(dest)).and_return(double(uid: 1, gid: 2, 'directory?': false))
 
-          expect(FileUtils).to receive(:chown).with(1, 2, /#{dest}/)
+          allow(File).to receive(:chown).and_call_original
+          expect(FileUtils).to receive(:chown).with(1, 2, any_args)
 
           Puppet::FileSystem.replace_file(dest, 0644) { |f| f.write(content) }
         end
@@ -1163,4 +1164,33 @@ describe "Puppet::FileSystem" do
       expect(File.mtime(dest)).to be_within(1).of(tomorrow)
     end
   end
+
+  context '#chmod' do
+    let(:dest) { tmpfile('abs_file') }
+
+    it "changes the mode given an absolute string" do
+      Puppet::FileSystem.touch(dest)
+      Puppet::FileSystem.chmod(0644, dest)
+      expect(File.stat(dest).mode & 0777).to eq(0644)
+    end
+
+    it "returns true if given an absolute pathname" do
+      Puppet::FileSystem.touch(dest)
+      Puppet::FileSystem.chmod(0644, Pathname.new(dest))
+      expect(File.stat(dest).mode & 0777).to eq(0644)
+    end
+
+    it "raises if the file doesn't exist" do
+      klass = Puppet::Util::Platform.windows? ? Puppet::Error : Errno::ENOENT
+      expect {
+        Puppet::FileSystem.chmod(0644, dest)
+      }.to raise_error(klass)
+    end
+
+    it "raises ArgumentError if dest is invalid" do
+      expect {
+        Puppet::FileSystem.chmod(0644, nil)
+      }.to raise_error(ArgumentError, /expected Pathname, got: 'NilClass'/)
+    end
+  end
 end

data/spec/unit/forge/module_release_spec.rb

@@ -90,7 +90,7 @@ describe Puppet::Forge::ModuleRelease do
         "checksums": { },
         "version": "#{module_version}",
         "description": "Standard Library for Puppet Modules",
-        "source": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
+        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "summary": "Puppet Module Standard Library",
         "dependencies": [
@@ -204,7 +204,7 @@ describe Puppet::Forge::ModuleRelease do
         "checksums": { },
         "version": "#{module_version}",
         "description": "Standard Library for Puppet Modules",
-        "source": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
+        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "summary": "Puppet Module Standard Library",
         "author": "#{module_author}",
@@ -279,7 +279,7 @@ describe Puppet::Forge::ModuleRelease do
         "checksums": { },
         "version": "#{module_version}",
         "description": "Standard Library for Puppet Modules",
-        "source": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
+        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "summary": "Puppet Module Standard Library",
         "dependencies": [