puppet 7.11.0-universal-darwin → 7.14.0-universal-darwin

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,6 +2,8 @@ require 'spec_helper'
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
+  include PuppetSpec::Files
+
   before do
     Puppet[:server] = "puppetmaster"
     Puppet[:report] = true
@@ -10,6 +12,17 @@ describe Puppet::Configurer do
     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] }
@@ -866,7 +879,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)
@@ -1222,7 +1235,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
@@ -1241,104 +1253,199 @@ describe Puppet::Configurer do
         SUMMARY
       end
 
-      it "prefers the environment set via cli" do
-        Puppet.settings.handlearg('--environment', 'usethis')
-        configurer.run
+      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
 
-        expect(configurer.environment).to eq('usethis')
-      end
+        it "prefers the environment set via cli" do
+          Puppet.settings.handlearg('--environment', 'usethis')
+          configurer.run
 
-      it "prefers the environment set via config" do
-        FileUtils.mkdir_p(Puppet[:confdir])
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [main]
-        environment = usethis
-        CONF
+          expect(configurer.environment).to eq('usethis')
+        end
 
-        Puppet.initialize_settings
-        configurer.run
+        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
 
-        expect(configurer.environment).to eq('usethis')
-      end
+          Puppet.initialize_settings
+          configurer.run
+
+          expect(configurer.environment).to eq(last_server_specified_environment)
+        end
 
-      it "uses 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 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])
+        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 environment is not set via CLI" do
-        it "uses the environment found in lastrunfile if the key exists" do
-          configurer.run
+      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(configurer.environment).to eq(last_server_specified_environment)
+        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 "uses environment from Puppet[:environment] if strict_environment_mode is set" do
-          Puppet[:strict_environment_mode] = true
+        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
 
-          expect(configurer.environment).to eq(Puppet[:environment])
+        it "uses the node environment from the node request" do
+          configurer.run
+
+          expect(configurer.environment).to eq(node_environment.name.to_s)
+        end
+      end
+    end
+
+    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 environment from Puppet[:environment] if initial_environment is the same as converged_environment" do
+        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
 

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": [