puppet 7.10.0-x64-mingw32 → 7.13.1-x64-mingw32

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/apply_spec.rb

@@ -10,21 +10,22 @@ describe Puppet::Application::Apply do
 
   before :each do
     @apply = Puppet::Application[:apply]
-    allow(Puppet::Util::Log).to receive(:newdestination)
     Puppet[:reports] = "none"
   end
 
-  [:debug,:loadclasses,:test,:verbose,:use_nodes,:detailed_exitcodes,:catalog, :write_catalog_summary].each do |option|
-    it "should declare handle_#{option} method" do
-      expect(@apply).to respond_to("handle_#{option}".to_sym)
-    end
-
+  [:debug,:loadclasses,:test,:verbose,:use_nodes,:detailed_exitcodes,:catalog].each do |option|
     it "should store argument value when calling handle_#{option}" do
       expect(@apply.options).to receive(:[]=).with(option, 'arg')
       @apply.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
+  it "should handle write_catalog_summary" do
+    @apply.send(:handle_write_catalog_summary, true)
+
+    expect(Puppet[:write_catalog_summary]).to eq(true)
+  end
+
   it "should set the code to the provided code when :execute is used" do
     expect(@apply.options).to receive(:[]=).with(:code, 'arg')
     @apply.send("handle_execute".to_sym, 'arg')
@@ -53,23 +54,18 @@ describe Puppet::Application::Apply do
     end
 
     describe "with --test" do
-      it "should call setup_test" do
-        @apply.options[:test] = true
-        expect(@apply).to receive(:setup_test)
-
-        @apply.setup
-      end
-
       it "should set options[:verbose] to true" do
         @apply.setup_test
 
         expect(@apply.options[:verbose]).to eq(true)
       end
+
       it "should set options[:show_diff] to true" do
         Puppet.settings.override_default(:show_diff, false)
         @apply.setup_test
         expect(Puppet[:show_diff]).to eq(true)
       end
+
       it "should set options[:detailed_exitcodes] to true" do
         @apply.setup_test
 
@@ -155,7 +151,7 @@ describe Puppet::Application::Apply do
   end
 
   describe "when executing" do
-    it "should dispatch to 'apply' if it was called with 'apply'" do
+    it "should dispatch to 'apply' if it was called with a catalog" do
       @apply.options[:catalog] = "foo"
 
       expect(@apply).to receive(:apply)
@@ -213,47 +209,52 @@ describe Puppet::Application::Apply do
         @apply.options[:code] = "code to run"
         expect(Puppet).to receive(:[]=).with(:code,"code to run")
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should set the code to run from STDIN if no arguments" do
-        allow(@apply.command_line).to receive(:args).and_return([])
+        @apply.command_line.args = []
         allow(STDIN).to receive(:read).and_return("code to run")
 
         expect(Puppet).to receive(:[]=).with(:code,"code to run")
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
         noexist = tmpfile('noexist.pp')
-        allow(@apply.command_line).to receive(:args).and_return([noexist])
-        expect { @apply.main }.to raise_error(RuntimeError, "Could not find file #{noexist}")
+        @apply.command_line.args << noexist
+        expect {
+          @apply.run
+        }.to exit_with(1)
+         .and output(anything).to_stdout
+         .and output(/Could not find file #{noexist}/).to_stderr
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
         manifest = tmpfile('starwarsIV')
         FileUtils.touch(manifest)
 
-        allow(@apply.command_line).to receive(:args).and_return([manifest, 'starwarsI', 'starwarsII'])
-
-        expect { @apply.main }.to exit_with 0
-
-        msg = @logs.find {|m| m.message =~ /Only one file can be applied per run/ }
-        expect(msg.message).to eq('Only one file can be applied per run.  Skipping starwarsI, starwarsII')
-        expect(msg.level).to eq(:warning)
+        @apply.command_line.args << manifest << 'starwarsI' << 'starwarsII'
+        expect {
+          @apply.run
+        }.to exit_with(0)
+         .and output(anything).to_stdout
+         .and output(/Warning: Only one file can be applied per run.  Skipping starwarsI, starwarsII/).to_stderr
       end
 
       it "should splay" do
         expect(@apply).to receive(:splay)
 
-        expect { @apply.main }.to exit_with 0
+        expect {
+          @apply.run
+        }.to exit_with(0).and output(anything).to_stdout
       end
 
-      it "should raise an error if we can't find the node" do
+      it "should exit with 1 if we can't find the node" do
         expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
 
-        expect { @apply.main }.to raise_error(RuntimeError, /Could not find node/)
+        expect { @apply.run }.to exit_with(1).and output(/Could not find node/).to_stderr
       end
 
       it "should load custom classes if loadclasses" do
@@ -264,18 +265,18 @@ describe Puppet::Application::Apply do
 
         expect(@node).to receive(:classes=).with(['class'])
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should compile the catalog" do
         expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it 'should called the DeferredResolver to resolve any Deferred values' do
         expect(Puppet::Pops::Evaluator::DeferredResolver).to receive(:resolve_and_replace).with(any_args)
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it 'should make the Puppet::Pops::Loaders available when applying the compiled catalog' do
@@ -285,47 +286,67 @@ describe Puppet::Application::Apply do
           fail('Loaders not found') unless Puppet.lookup(:loaders) { nil }.is_a?(Puppet::Pops::Loaders)
           true
         end.and_return(0)
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should transform the catalog to ral" do
         expect(@catalog).to receive(:to_ral).and_return(@catalog)
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should finalize the catalog" do
         expect(@catalog).to receive(:finalize)
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should not save the classes or resource file by default" do
         expect(@catalog).not_to receive(:write_class_file)
         expect(@catalog).not_to receive(:write_resource_file)
-        expect { @apply.main }.to exit_with 0
+
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
-      it "should save the classes and resources files when requested" do
-        @apply.options[:write_catalog_summary] = true
+      it "should save the classes and resources files when requested on the command line using dashes" do
+        expect(@catalog).to receive(:write_class_file).once
+        expect(@catalog).to receive(:write_resource_file).once
+
+        # dashes are parsed by the application's OptionParser
+        @apply.command_line.args = ['--write-catalog-summary']
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+      end
+
+      it "should save the classes and resources files when requested on the command line using underscores" do
+        expect(@catalog).to receive(:write_class_file).once
+        expect(@catalog).to receive(:write_resource_file).once
+
+        # underscores are parsed by the settings PuppetOptionParser
+        @apply.command_line.args = ['--write_catalog_summary']
+        Puppet.initialize_settings(['--write_catalog_summary'])
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
+      end
+
+      it "should save the classes and resources files when specified as a setting" do
+        Puppet[:write_catalog_summary] = true
 
         expect(@catalog).to receive(:write_class_file).once
         expect(@catalog).to receive(:write_resource_file).once
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
         expect_any_instance_of(Puppet::Configurer).to receive(:execute_prerun_command).and_return(true)
         expect_any_instance_of(Puppet::Configurer).to receive(:execute_postrun_command).and_return(true)
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should apply the catalog" do
         expect(@catalog).to receive(:apply).and_return(double('transaction'))
 
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       it "should save the last run summary" do
@@ -334,7 +355,7 @@ describe Puppet::Application::Apply do
         allow(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
         expect_any_instance_of(Puppet::Configurer).to receive(:save_last_run_summary).with(report)
-        expect { @apply.main }.to exit_with 0
+        expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
       end
 
       describe "when using node_name_fact" do
@@ -347,27 +368,27 @@ describe Puppet::Application::Apply do
         end
 
         it "should set the facts name based on the node_name_fact" do
-          expect { @apply.main }.to exit_with 0
+          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
           expect(@facts.name).to eq('other_node_name')
         end
 
         it "should set the node_name_value based on the node_name_fact" do
-          expect { @apply.main }.to exit_with 0
+          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
           expect(Puppet[:node_name_value]).to eq('other_node_name')
         end
 
         it "should merge in our node the loaded facts" do
           @facts.values.merge!('key' => 'value')
 
-          expect { @apply.main }.to exit_with 0
+          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
 
           expect(@node.parameters['key']).to eq('value')
         end
 
-        it "should raise an error if we can't find the facts" do
+        it "should exit if we can't find the facts" do
           expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(nil)
 
-          expect { @apply.main }.to raise_error(RuntimeError, /Could not find facts/)
+          expect { @apply.run }.to exit_with(1).and output(/Could not find facts/).to_stderr
         end
       end
 
@@ -380,14 +401,14 @@ describe Puppet::Application::Apply do
           Puppet[:noop] = false
           allow_any_instance_of(Puppet::Transaction::Report).to receive(:exit_status).and_return(666)
 
-          expect { @apply.main }.to exit_with 666
+          expect { @apply.run }.to exit_with(666).and output(anything).to_stdout
         end
 
         it "should exit with report's computed exit status, even if --noop is set" do
           Puppet[:noop] = true
           allow_any_instance_of(Puppet::Transaction::Report).to receive(:exit_status).and_return(666)
 
-          expect { @apply.main }.to exit_with 666
+          expect { @apply.run }.to exit_with(666).and output(anything).to_stdout
         end
 
         it "should always exit with 0 if option is disabled" do
@@ -395,7 +416,7 @@ describe Puppet::Application::Apply do
           report = double('report', :exit_status => 666)
           allow(@transaction).to receive(:report).and_return(report)
 
-          expect { @apply.main }.to exit_with 0
+          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
         end
 
         it "should always exit with 0 if --noop" do
@@ -403,7 +424,7 @@ describe Puppet::Application::Apply do
           report = double('report', :exit_status => 666)
           allow(@transaction).to receive(:report).and_return(report)
 
-          expect { @apply.main }.to exit_with 0
+          expect { @apply.run }.to exit_with(0).and output(anything).to_stdout
         end
       end
     end
@@ -503,16 +524,15 @@ describe Puppet::Application::Apply do
         }
       CODE
 
-      @apply.options[:write_catalog_summary] = true
-
+      Puppet.settings[:write_catalog_summary] = true
       Puppet.settings[:resourcefile] = resourcefile
       Puppet.settings[:classfile] = classfile
 
       #We don't actually need the resource to do anything, we are using it's properties in other parts of the workflow.
-      allow(Puppet::Util::Execution).to receive(:execute)
-
-      expect { @apply.main }.to exit_with 0
+      allow_any_instance_of(Puppet::Type.type(:exec).defaultprovider).to receive(:which).and_return('cat')
+      allow(Puppet::Util::Execution).to receive(:execute).and_return(double(exitstatus: 0, output: ''))
 
+      expect { @apply.run }.to exit_with(0).and output(%r{Exec\[do it\]/returns: executed successfully}).to_stdout
       result = File.read(resourcefile)
 
       expect(result).not_to match(/secret_file_name/)

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/application/resource_spec.rb

@@ -129,6 +129,35 @@ describe Puppet::Application::Resource do
   end
 
   describe "when printing output" do
+    it "should not emit puppet class tags when printing yaml" do
+      Puppet::Type.newtype(:stringify) do
+        ensurable
+        newparam(:name, isnamevar: true)
+        newproperty(:string)
+      end
+
+      Puppet::Type.type(:stringify).provide(:stringify) do
+        def exists?
+          true
+        end
+
+        def string
+          Puppet::Util::Execution::ProcessOutput.new('test', 0)
+        end
+      end
+
+      @resource_app.options[:to_yaml] = true
+      allow(@resource_app.command_line).to receive(:args).and_return(['stringify', 'hello', 'ensure=present', 'string=asd'])
+      expect(@resource_app).to receive(:puts).with(<<~YAML)
+      ---
+      stringify:
+        hello:
+          ensure: present
+          string: test
+      YAML
+      expect { @resource_app.main }.not_to raise_error
+    end
+
     it "should ensure all values to be printed are in the external encoding" do
       resources = [
         Puppet::Type.type(:user).new(:name => "\u2603".force_encoding(Encoding::UTF_8)).to_resource,

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