puppet 6.16.0-universal-darwin → 7.0.0-universal-darwin

data/spec/integration/configurer_spec.rb

@@ -60,6 +60,20 @@ describe Puppet::Configurer do
       expect(summary["time"]["last_run"]).to be_between(t1, t2)
     end
 
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true" do
+      Puppet[:ignore_plugin_errors] = false
+
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = true
+
+      report = Puppet::Transaction::Report.new
+      expect_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate).and_raise(Puppet::Error, 'Failed to retrieve: some file')
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
+
+      @configurer.run(pluginsync: true, report: report)
+      expect(report.cached_catalog_status).to eq('on_failure')
+    end
+
     describe 'resubmitting facts' do
       context 'when resubmit_facts is set to false' do
         it 'should not send data' do

data/spec/integration/data_binding_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'puppet/indirector/hiera'
 
 require 'puppet_spec/compiler'
+require 'puppet/indirector/data_binding/hiera'
 
 describe "Data binding" do
   include PuppetSpec::Files
@@ -140,6 +141,71 @@ describe "Data binding" do
     end
   end
 
+  context "with plan_hierarchy key" do
+    context "using Hiera 5" do
+      let(:hiera_config) { <<~CONF  }
+      ---
+      version: 5
+      plan_hierarchy:
+        - path: global
+          name: Common
+      CONF
+
+      it "ignores plan_hierarchy outside of a Bolt plan" do
+        configure_hiera_for_plan_hierarchy(data, hiera_config)
+
+        create_manifest_in_module("testing", "binding.pp",
+                                  <<-MANIFEST)
+      class testing::binding($value) {}
+        MANIFEST
+
+        expect { compile_to_catalog("include testing::binding") }
+          .to raise_error(/Class\[Testing::Binding\]: expects a value for parameter 'value'/)
+      end
+    end
+
+    context "with invalid data" do
+      let(:hiera_config) { <<~CONF  }
+      ---
+      version: 5
+      plan_hierarchy:
+        - pop: the question
+      CONF
+
+      it "raises a validation error" do
+        configure_hiera_for_plan_hierarchy(data, hiera_config)
+
+        create_manifest_in_module("testing", "binding.pp",
+                                  <<-MANIFEST)
+      class testing::binding($value) {}
+        MANIFEST
+
+        expect { compile_to_catalog("include testing::binding") }
+          .to raise_error(/entry 'plan_hierarchy' index 0 unrecognized key 'pop'/)
+      end
+    end
+
+    context "with Hiera 3" do
+      let(:hiera_config) { <<~CONF  }
+      ---
+      plan_hierarchy: ['global']
+      CONF
+
+      it "errors with plan_hierarchy key" do
+        configure_hiera_for_plan_hierarchy(data, hiera_config)
+
+        create_manifest_in_module("testing", "binding.pp",
+                                  <<-MANIFEST)
+      class testing::binding($value) {}
+        MANIFEST
+
+        expect { compile_to_catalog("include testing::binding") }
+          .to raise_error(/unrecognized key 'plan_hierarchy'/)
+
+      end
+    end
+  end
+
 
   def configure_hiera_for_one_tier(data)
     hiera_config_file = tmpfile("hiera.yaml")
@@ -163,6 +229,22 @@ describe "Data binding" do
     Puppet[:hiera_config] = hiera_config_file
   end
 
+  def configure_hiera_for_plan_hierarchy(data, config)
+    hiera_config_file = tmpfile("hiera.yaml")
+
+    File.open(hiera_config_file, 'w:UTF-8') do |f|
+      f.write(config)
+    end
+
+    data.each do | file, contents |
+      File.open(File.join(dir, "#{file}.yaml"), 'w:UTF-8') do |f|
+        f.write(YAML.dump(contents))
+      end
+    end
+
+    Puppet[:hiera_config] = hiera_config_file
+  end
+
   def configure_hiera_for_two_tier(data)
     hiera_config_file = tmpfile("hiera.yaml")
 

data/spec/integration/defaults_spec.rb

@@ -23,6 +23,26 @@ describe "Puppet defaults" do
     end
   end
 
+  describe "when setting the :masterport" do
+    it "should also set :serverport to the same value" do
+      Puppet.settings[:masterport] = 3939
+      expect(Puppet.settings[:serverport]).to eq(3939)
+    end
+
+    it "should not overwrite :serverport if explicitly set" do
+      Puppet.settings[:serverport] = 9000
+      Puppet.settings[:masterport] = 9001
+      expect(Puppet.settings[:serverport]).to eq(9000)
+    end
+  end
+
+  describe "when setting the :serverport" do
+    it "should also set the :masterport to the same value" do
+      Puppet.settings[:serverport] = 9000
+      expect(Puppet.settings[:masterport]).to eq(9000)
+    end
+  end
+
   describe "when setting the :factpath" do
     it "should add the :factpath to Facter's search paths" do
       expect(Facter).to receive(:search).with("/my/fact/path")
@@ -130,8 +150,7 @@ describe "Puppet defaults" do
       Puppet::Util.withenv( {"PATH" => path }, :windows) do
         Puppet.settings[:path] = "none" # this causes it to ignore the setting
 
-        envhash = Puppet::Util::Windows::Process.get_environment_strings
-        expect(envhash['Path']).to eq(path)
+        expect(Puppet::Util.get_env('Path')).to eq(path)
       end
     end
   end
@@ -140,6 +159,10 @@ describe "Puppet defaults" do
     expect(Puppet.settings.value(:preferred_serialization_format)).to eq("json")
   end
 
+  it "should default to true the disable_i18n setting" do
+    expect(Puppet.settings.value(:disable_i18n)).to eq(true)
+  end
+
   it "should have a setting for determining the configuration version and should default to an empty string" do
     expect(Puppet.settings[:config_version]).to eq("")
   end
@@ -150,15 +173,20 @@ describe "Puppet defaults" do
       expect(Puppet.settings[:report_server]).to eq("server")
     end
 
+    it "should use the default serverport value when report port is unspecified" do
+      Puppet.settings[:serverport] = "1234"
+      expect(Puppet.settings[:report_port]).to eq(1234)
+    end
+
     it "should use the default masterport value when report port is unspecified" do
       Puppet.settings[:masterport] = "1234"
-      expect(Puppet.settings[:report_port]).to eq("1234")
+      expect(Puppet.settings[:report_port]).to eq(1234)
     end
 
     it "should use report_port when set" do
-      Puppet.settings[:masterport] = "1234"
+      Puppet.settings[:serverport] = "1234"
       Puppet.settings[:report_port] = "5678"
-      expect(Puppet.settings[:report_port]).to eq("5678")
+      expect(Puppet.settings[:report_port]).to eq(5678)
     end
   end
 

data/spec/integration/directory_environments_spec.rb

@@ -2,11 +2,7 @@ require 'spec_helper'
 
 describe "directory environments" do
   let(:args) { ['--configprint', 'modulepath', '--environment', 'direnv'] }
-  let(:puppet) do
-    app = Puppet::Application[:apply]
-    allow(app).to receive(:command_line).and_return(double('command_line', :args => []))
-    app
-  end
+  let(:puppet) { Puppet::Application[:apply] }
 
   context "with a single directory environmentpath" do
     before(:each) do
@@ -17,17 +13,19 @@ describe "directory environments" do
 
     it "config prints the environments modulepath" do
       Puppet.settings.initialize_global_settings(args)
-      expect do
-        expect { puppet.run }.to exit_with(0)
-      end.to have_printed('/direnv/modules')
+      expect {
+        puppet.run
+      }.to exit_with(0)
+       .and output(%r{/direnv/modules}).to_stdout
     end
 
     it "config prints the cli --modulepath despite environment" do
       args << '--modulepath' << '/completely/different'
       Puppet.settings.initialize_global_settings(args)
-      expect do
-        expect { puppet.run }.to exit_with(0)
-      end.to have_printed('/completely/different')
+      expect {
+        puppet.run
+      }.to exit_with(0)
+       .and output(%r{/completely/different}).to_stdout
     end
 
     it 'given an 8.3 style path on Windows, will config print an expanded path',
@@ -41,9 +39,10 @@ describe "directory environments" do
       expect(Puppet[:environmentpath]).to match(/~/)
 
       Puppet.settings.initialize_global_settings(args)
-      expect do
-        expect { puppet.run }.to exit_with(0)
-      end.to have_printed(expanded)
+      expect {
+        puppet.run
+      }.to exit_with(0)
+       .and output(a_string_matching(expanded)).to_stdout
     end
   end
 
@@ -59,9 +58,10 @@ describe "directory environments" do
 
     it "config prints a directory environment modulepath" do
       Puppet.settings.initialize_global_settings(args)
-      expect do
-        expect { puppet.run }.to exit_with(0)
-      end.to have_printed('otherdirenv/modules')
+      expect {
+        puppet.run
+      }.to exit_with(0)
+       .and output(%r{otherdirenv/modules}).to_stdout
     end
   end
 end

data/spec/integration/environments/setting_hooks_spec.rb

@@ -12,7 +12,7 @@ describe "setting hooks" do
     end
 
     it "accesses correct directory environment settings after initializing a setting with an on_write hook" do
-      expect(Puppet.settings.setting(:certname).call_hook).to eq(:on_write_only) 
+      expect(Puppet.settings.setting(:strict).call_hook).to eq(:on_write_only)
 
       File.open(File.join(confdir, "puppet.conf"), "w:UTF-8") do |f|
         f.puts("environmentpath=#{environmentpath}")

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

@@ -43,9 +43,10 @@ describe Puppet::Node::Facts::Facter do
       Puppet.initialize_settings(['--modulepath', factdir])
       apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => ['--modulepath', factdir, '-e', 'notify { $custom: }']))
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed(Puppet.version)
+      expect {
+        apply.run
+      }.to exit_with(0)
+       .and output(/defined 'message' as '#{Puppet.version}'/).to_stdout
     end
 
     it "should resolve external facts" do
@@ -58,9 +59,10 @@ describe Puppet::Node::Facts::Facter do
       Puppet.initialize_settings(['--pluginfactdest', factdir])
       apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => ['--pluginfactdest', factdir, '-e', 'notify { $foo: }']))
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed('bar')
+      expect {
+        apply.run
+      }.to exit_with(0)
+       .and output(/defined 'message' as 'bar'/).to_stdout
     end
   end
 

data/spec/integration/network/http_pool_spec.rb

@@ -81,16 +81,6 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
         end
       end
 
-      it "doesn't generate a Puppet::SSL::Host deprecation warning" do
-        server.start_server do |port|
-          http = connection(hostname, port)
-          res = http.get('/')
-          expect(res.code).to eq('200')
-        end
-
-        expect(@logs).to eq([])
-      end
-
       it "detects when the server has closed the connection and reconnects" do
         server.start_server do |port|
           http = connection(hostname, port)
@@ -101,17 +91,13 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
       end
     end
 
-    context "when using single use HTTPS connections" do
-      include_examples 'HTTPS client'
-    end
-
     context "when using persistent HTTPS connections" do
       around :each do |example|
-        pool = Puppet::Network::HTTP::Pool.new(15)
-        Puppet.override(:http_pool => pool) do
+        begin
           example.run
+        ensure
+          Puppet.runtime[:http].close
         end
-        pool.close
       end
 
       include_examples 'HTTPS client'
@@ -122,7 +108,7 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
         Puppet::Network::HttpPool.http_client_class = klass
       end
 
-      it "connects using the scheme, host and port from the http instance" do
+      it "connects using the scheme, host and port from the http instance preserving the URL path and query" do
         request_line = nil
 
         response_proc = -> (req, res) {
@@ -131,20 +117,20 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
 
         server.start_server(response_proc: response_proc) do |port|
           http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
-          path  = "http://bogus.example.com:443/foo"
+          path  = "http://bogus.example.com:443/foo?q=a"
           http.get(path)
 
           if legacy_api
-            # The old API passed the bogus hostname which didn't match
-            # the host we connected to.
-            expect(request_line).to eq("GET http://bogus.example.com:443/foo HTTP/1.1\r\n")
+            # The old API uses 'absolute-form' and passes the bogus hostname
+            # which isn't the host we connected to.
+            expect(request_line).to eq("GET http://bogus.example.com:443/foo?q=a HTTP/1.1\r\n")
           else
-            expect(request_line).to eq("GET /foo HTTP/1.1\r\n")
+            expect(request_line).to eq("GET /foo?q=a HTTP/1.1\r\n")
           end
         end
       end
 
-      it "requires the caller to URL encode the path" do
+      it "requires the caller to URL encode the path and query when using absolute form" do
         request_line = nil
 
         response_proc = -> (req, res) {
@@ -153,23 +139,36 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
 
         server.start_server(response_proc: response_proc) do |port|
           http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
-          encoded_url = "https://#{hostname}:#{port}/foo%20bar"
+          params = { 'key' => 'a value' }
+          encoded_url = "https://#{hostname}:#{port}/foo%20bar?q=#{Puppet::Util.uri_query_encode(params.to_json)}"
           http.get(encoded_url)
 
           if legacy_api
             expect(request_line).to eq("GET #{encoded_url} HTTP/1.1\r\n")
           else
-            expect(request_line).to eq("GET /foo%20bar HTTP/1.1\r\n")
+            expect(request_line).to eq("GET /foo%20bar?q=%7B%22key%22%3A%22a%20value%22%7D HTTP/1.1\r\n")
           end
         end
       end
-    end
 
-    describe Puppet::Network::HTTP::Connection do
-      it_behaves_like "an HttpPool connection", described_class, true
+      it "requires the caller to URL encode the path and query when using a path" do
+        request_line = nil
+
+        response_proc = -> (req, res) {
+          request_line = req.request_line
+        }
+
+        server.start_server(response_proc: response_proc) do |port|
+          http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
+          params = { 'key' => 'a value' }
+          http.get("/foo%20bar?q=#{Puppet::Util.uri_query_encode(params.to_json)}")
+
+          expect(request_line).to eq("GET /foo%20bar?q=%7B%22key%22%3A%22a%20value%22%7D HTTP/1.1\r\n")
+        end
+      end
     end
 
-    describe Puppet::Network::HTTP::ConnectionAdapter do
+    describe Puppet::Network::HTTP::Connection do
       it_behaves_like "an HttpPool connection", described_class, false
     end
   end

data/spec/integration/node/environment_spec.rb

@@ -79,7 +79,7 @@ describe Puppet::Node::Environment do
   it "should not yield a module with the same name as a defined Bolt project" do
     project_path = File.join(tmpfile('project'), 'bolt_project')
     FileUtils.mkdir_p(project_path)
-    project = Struct.new("Project", :name, :path).new('project', project_path)
+    project = Struct.new("Project", :name, :path, :load_as_module?).new('project', project_path, true)
 
     Puppet.override(bolt_project: project) do
       base = tmpfile("base")

data/spec/integration/parser/catalog_spec.rb

@@ -48,44 +48,6 @@ describe "A catalog" do
         expect(resources_in(agent_catalog)).
           to include_in_order(*resources_in_declaration_order)
       end
-
-      it "does not contain unrealized, virtual resources" do
-        virtual_resources = ["Unrealized[unreal]", "Class[Unreal]"]
-
-        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-          class unreal { }
-          define unrealized() { }
-
-          class real {
-            @unrealized { "unreal": }
-            @class { "unreal": }
-          }
-
-          include real
-        EOM
-
-        expect(resources_in(master_catalog)).to_not include(*virtual_resources)
-        expect(resources_in(agent_catalog)).to_not include(*virtual_resources)
-      end
-
-      it "does not contain unrealized, exported resources" do
-        exported_resources = ["Unrealized[unreal]", "Class[Unreal]"]
-
-        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-          class unreal { }
-          define unrealized() { }
-
-          class real {
-            @@unrealized { "unreal": }
-            @@class { "unreal": }
-          }
-
-          include real
-        EOM
-
-        expect(resources_in(master_catalog)).to_not include(*exported_resources)
-        expect(resources_in(agent_catalog)).to_not include(*exported_resources)
-      end
     end
   end