puppet 6.17.0-x64-mingw32 → 7.1.0-x64-mingw32

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")
@@ -139,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
@@ -149,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'
@@ -183,10 +169,6 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
     end
 
     describe Puppet::Network::HTTP::Connection do
-      it_behaves_like "an HttpPool connection", described_class, true
-    end
-
-    describe Puppet::Network::HTTP::ConnectionAdapter 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
 

data/spec/integration/parser/node_spec.rb

@@ -117,15 +117,6 @@ describe 'node statements' do
       expect(catalog).to have_resource('Notify[matched]')
     end
 
-    it 'selects a node that is a prefix of the agent name' do
-      Puppet[:strict_hostname_checking] = false
-      catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("node.name.com"))
-      node 'node.name' { notify { matched: } }
-      MANIFEST
-
-      expect(catalog).to have_resource('Notify[matched]')
-    end
-
     it 'does not treat regex symbols as a regex inside a string literal' do
       catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodexname"))
       node 'node.name' { notify { 'not matched': } }

data/spec/integration/parser/pcore_resource_spec.rb

@@ -68,16 +68,6 @@ describe 'when pcore described resources types are in use' do
                 end
               end
             RUBY
-            'cap.rb' => <<-EOF
-            module Puppet
-            Type.newtype(:cap, :is_capability => true) do
-              @doc = "Docs for capability"
-              @isomorphic = false
-              newproperty(:message) do
-                desc "Docs for 'message' property"
-              end
-            end;end
-            EOF
            } } },
         }
       }}})
@@ -126,14 +116,10 @@ describe 'when pcore described resources types are in use' do
         test3 { 'x/y':
           message => 'x/y works'
         }
-        cap { 'c':
-          message => 'c works'
-        }
       MANIFEST
       expect(catalog.resource(:test1, "a")['message']).to eq('a works')
       expect(catalog.resource(:test2, "b")['message']).to eq('b works')
       expect(catalog.resource(:test3, "x/y")['message']).to eq('x/y works')
-      expect(catalog.resource(:cap, "c")['message']).to eq('c works')
     end
 
     it 'the validity of attribute names are checked' do
@@ -158,20 +144,6 @@ describe 'when pcore described resources types are in use' do
       expect(catalog.resource(:test1, "a")['noop']).to eq(true)
     end
 
-    it 'capability is propagated to the catalog' do
-      genface.types
-      catalog = compile_to_catalog(<<-MANIFEST)
-        test2 { 'r':
-          message => 'a resource'
-        }
-        cap { 'c':
-          message => 'a cap'
-        }
-      MANIFEST
-      expect(catalog.resource(:test2, "r").is_capability?).to eq(false)
-      expect(catalog.resource(:cap, "c").is_capability?).to eq(true)
-    end
-
     it 'a generated type describes if it is isomorphic' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')
@@ -181,15 +153,6 @@ describe 'when pcore described resources types are in use' do
       end
     end
 
-    it 'a generated type describes if it is a capability' do
-      generate_and_in_a_compilers_context do |compiler|
-        t1 = find_resource_type(compiler.topscope, 'test1')
-        expect(t1.is_capability?).to be(false)
-        t2 = find_resource_type(compiler.topscope, 'cap')
-        expect(t2.is_capability?).to be(true)
-      end
-    end
-
     it 'a generated type returns parameters defined in pcore' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')