puppet 5.0.0 → 6.0.0

data/spec/unit/configurer/downloader_spec.rb

@@ -104,7 +104,7 @@ describe Puppet::Configurer::Downloader do
       end
     end
 
-    describe "on Windows", :if => Puppet.features.microsoft_windows? do
+    describe "on Windows", :if => Puppet::Util::Platform.windows? do
       it "should omit the owner" do
         file = generate_file_resource(:path => 'C:/path')
 
@@ -160,6 +160,11 @@ describe Puppet::Configurer::Downloader do
       expect(@dler.catalog.host_config).to eq(false)
     end
 
+    it "should not issue a deprecation warning for source_permissions" do
+      Puppet.expects(:puppet_deprecation_warning).never
+      catalog = @dler.catalog
+      expect(catalog.resources.size).to eq(1) # Must consume catalog to fix warnings
+    end
   end
 
   describe "when downloading" do

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -4,33 +4,61 @@ require 'puppet/configurer'
 require 'puppet/configurer/plugin_handler'
 
 describe Puppet::Configurer::PluginHandler do
-  let(:factory)       { Puppet::Configurer::DownloaderFactory.new }
-  let(:pluginhandler) { Puppet::Configurer::PluginHandler.new(factory) }
+  let(:pluginhandler) { Puppet::Configurer::PluginHandler.new() }
   let(:environment)   { Puppet::Node::Environment.create(:myenv, []) }
 
-  before :each do
-    # PluginHandler#load_plugin has an extra-strong rescue clause
-    # this mock is to make sure that we don't silently ignore errors
-    Puppet.expects(:err).never
+  context "server agent version is 5.3.4" do
+    before :each do
+      # PluginHandler#load_plugin has an extra-strong rescue clause
+      # this mock is to make sure that we don't silently ignore errors
+      Puppet.expects(:err).never
+      # Server_agent version needs to be at 5.3.4 in order to mount locales
+      Puppet.push_context({:server_agent_version => "5.3.4"})
+    end
+
+    it "downloads plugins, facts, and locales" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
+
+      pluginhandler.download_plugins(environment)
+    end
+
+    it "returns downloaded plugin, fact, and locale filenames" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
+
+      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b /c])
+    end
   end
 
-  it "downloads plugins and facts" do
-    plugin_downloader = stub('plugin-downloader', :evaluate => [])
-    facts_downloader = stub('facts-downloader', :evaluate => [])
+  context "server agent version is 5.3.3" do
+    before :each do
+      # PluginHandler#load_plugin has an extra-strong rescue clause
+      # this mock is to make sure that we don't silently ignore errors
+      Puppet.expects(:err).never
+      # Server_agent version needs to be at 5.3.4 in order to mount locales
+      Puppet.push_context({:server_agent_version => "5.3.3"})
+    end
 
-    factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-    factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
+    it "returns downloaded plugin, fact, but not locale filenames" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
-    pluginhandler.download_plugins(environment)
+      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
+    end
   end
 
-  it "returns downloaded plugin and fact filenames" do
-    plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
-    facts_downloader = stub('facts-downloader', :evaluate => %w[/b])
+  context "blank server agent version" do
+    before :each do
+      # PluginHandler#load_plugin has an extra-strong rescue clause
+      # this mock is to make sure that we don't silently ignore errors
+      Puppet.expects(:err).never
+      # Server_agent version needs to be at 5.3.4 in order to mount locales
+      # A blank version will default to 0.0
+      Puppet.push_context({:server_agent_version => ""})
+    end
 
-    factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-    factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
+    it "returns downloaded plugin, fact, but not locale filenames" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
-    expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
+      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
+    end
   end
 end

data/spec/unit/configurer_spec.rb

@@ -200,7 +200,7 @@ describe Puppet::Configurer do
     end
 
     it "should create report with passed transaction_uuid and job_id" do
-      @agent = Puppet::Configurer.new(Puppet::Configurer::DownloaderFactory.new, "test_tuuid", "test_jid")
+      @agent = Puppet::Configurer.new("test_tuuid", "test_jid")
       @agent.stubs(:init_storage)
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
@@ -264,6 +264,12 @@ describe Puppet::Configurer do
       expect(@agent.run).to eq(1234)
     end
 
+    it "should return nil if catalog application fails" do
+      @catalog.expects(:apply).raises(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+      report = Puppet::Transaction::Report.new
+      expect(@agent.run(catalog: @catalog, report: report)).to be_nil
+    end
+
     it "should send the transaction report even if the pre-run command fails" do
       report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
@@ -352,6 +358,35 @@ describe Puppet::Configurer do
       expect(@agent.run).to be_nil
     end
 
+    it 'includes total time metrics in the report after successfully applying the catalog' do
+      report = Puppet::Transaction::Report.new
+      @catalog.stubs(:apply).with() {|options| options[:report] == report }
+      @agent.run(report: report)
+
+      expect(report.metrics['time']).to be
+      expect(report.metrics['time']['total']).to be_a_kind_of(Numeric)
+    end
+
+    it 'includes total time metrics in the report even if prerun fails' do
+      Puppet.settings[:prerun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      report = Puppet::Transaction::Report.new
+      @agent.run(report: report)
+
+      expect(report.metrics['time']).to be
+      expect(report.metrics['time']['total']).to be_a_kind_of(Numeric)
+    end
+
+    it 'includes total time metrics in the report even if catalog retrieval fails' do
+      report = Puppet::Transaction::Report.new
+      @agent.stubs(:prepare_and_retrieve_catalog_from_cache).raises
+      @agent.run(:report => report)
+
+      expect(report.metrics['time']).to be
+      expect(report.metrics['time']['total']).to be_a_kind_of(Numeric)
+    end
+
     it "should refetch the catalog if the server specifies a new environment in the catalog" do
       catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
       @agent.expects(:retrieve_catalog).returns(catalog).twice
@@ -399,7 +434,7 @@ describe Puppet::Configurer do
 
     it "sets the checksum_type query param to the default supported_checksum_types in a catalog request" do
       Puppet::Resource::Catalog.indirection.expects(:find).with(anything,
-        has_entries(:checksum_type => 'md5.sha256'))
+        has_entries(:checksum_type => 'md5.sha256.sha384.sha512.sha224'))
       @agent.run
     end
 
@@ -431,7 +466,13 @@ describe Puppet::Configurer do
     describe "when using a REST terminus for catalogs" do
       it "should pass the prepared facts and the facts format as arguments when retrieving the catalog" do
         Puppet::Resource::Catalog.indirection.terminus_class = :rest
-        @agent.expects(:facts_for_uploading).returns(:facts => "myfacts", :facts_format => :foo)
+        # the "facts_for_uploading" are prepeared by first finding facts, and then encoding them
+        # this mocks the "find" with a special value 12345, which is then expected back in the
+        # call to "encode" - the encode in turn returns mocked data that is asserted as being
+        # presented to the catalog terminus as options.
+        #
+        @agent.expects(:find_facts).returns(12345)
+        @agent.expects(:encode_facts).with(12345).returns(:facts => "myfacts", :facts_format => :foo)
         Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options|
           options[:facts] == "myfacts" and options[:facts_format] == :foo
         }.returns @catalog
@@ -444,7 +485,7 @@ describe Puppet::Configurer do
   describe "when initialized with a transaction_uuid" do
     it "stores it" do
       SecureRandom.expects(:uuid).never
-      configurer = Puppet::Configurer.new(Puppet::Configurer::DownloaderFactory.new, 'foo')
+      configurer = Puppet::Configurer.new('foo')
       expect(configurer.instance_variable_get(:@transaction_uuid) == 'foo')
     end
   end
@@ -877,6 +918,20 @@ describe Puppet::Configurer do
       @agent.retrieve_catalog({})
       expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
     end
+
+    it "should not update the cached catalog in noop mode" do
+      Puppet[:noop] = true
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:ignore_cache => true, :ignore_cache_save => true)).returns(@catalog)
+
+      @agent.retrieve_catalog({})
+    end
+
+    it "should update the cached catalog when not in noop mode" do
+      Puppet[:noop] = false
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:ignore_cache => true, :ignore_cache_save => false)).returns(@catalog)
+
+      @agent.retrieve_catalog({})
+    end
   end
 
   describe "when converting the catalog" do
@@ -916,23 +971,16 @@ describe Puppet::Configurer do
 
       @agent.convert_catalog(catalog, 10)
     end
-  end
-
-  describe "when determining whether to pluginsync" do
-    it "should default to Puppet[:pluginsync] when explicitly set by the commandline" do
-      Puppet.settings[:pluginsync] = false
-      Puppet.settings.expects(:set_by_cli?).returns(true)
-
-      expect(described_class).not_to be_should_pluginsync
-    end
 
-    it "should default to Puppet[:pluginsync] when explicitly set by config" do
-      Puppet.settings[:pluginsync] = false
-      Puppet.settings.expects(:set_by_config?).returns(true)
+    it "should set catalog conversion time on the report" do
+      report = Puppet::Transaction::Report.new
 
-      expect(described_class).not_to be_should_pluginsync
+      report.expects(:add_times).with(:convert_catalog, kind_of(Numeric))
+      @agent.convert_catalog(catalog, 10, {:report => report})
     end
+  end
 
+  describe "when determining whether to pluginsync" do
     it "should be true if use_cached_catalog is false" do
       Puppet.settings[:use_cached_catalog] = false
 
@@ -962,32 +1010,41 @@ describe Puppet::Configurer do
 
     it "should select a server when provided" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
-      Puppet::Network::HTTP::Pool.expects(:new).returns(pool)
-      Puppet.expects(:override).with({:http_pool => pool}).yields
-      Puppet.expects(:override).with({:server => "myserver", :serverport => '123'}).twice.yields
-      Puppet::Node.indirection.expects(:find).returns(nil)
-      @agent.expects(:run_internal).returns(nil)
+      response = Net::HTTPOK.new(nil, 200, 'OK')
+      Puppet::Network::HttpPool.stubs(:http_ssl_instance).with('myserver', '123').returns(mock('request', get: response))
+      @agent.stubs(:run_internal)
+
+      options = {}
+      @agent.run(options)
+      expect(options[:report].master_used).to eq('myserver:123')
+    end
+
+    it "should report when a server is unavailable" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      response = Net::HTTPInternalServerError.new(nil, 500, 'Internal Server Error')
+      Puppet::Network::HttpPool.stubs(:http_ssl_instance).with('myserver', '123').returns(mock('request', get: response))
+      @agent.stubs(:run_internal)
+
+      Puppet.expects(:debug).with("Puppet server myserver:123 is unavailable: 500 Internal Server Error")
       @agent.run
     end
 
     it "should fallback to an empty server when failover fails" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
-      Puppet::Network::HTTP::Pool.expects(:new).returns(pool)
-      Puppet.expects(:override).with({:http_pool => pool}).yields
-      Puppet.expects(:override).with({:server => "myserver", :serverport => '123'}).yields
-      Puppet.expects(:override).with({:server => nil, :serverport => nil}).yields
       error = Net::HTTPError.new(400, 'dummy server communication error')
-      Puppet::Node.indirection.expects(:find).raises(error)
-      @agent.expects(:run_internal).returns(nil)
-      @agent.run
+      Puppet::Network::HttpPool.stubs(:http_ssl_instance).with('myserver', '123').returns(error)
+      @agent.stubs(:run_internal)
+
+      options = {}
+      @agent.run(options)
+      expect(options[:report].master_used).to be_nil
     end
 
     it "should not make multiple node requets when the server is found" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      Puppet::Node.indirection.expects(:find).returns("mynode").once
-      @agent.expects(:prepare_and_retrieve_catalog).returns(nil)
+      Puppet::Network::HttpPool.expects(:http_ssl_instance).once
+      @agent.stubs(:run_internal)
+
       @agent.run
     end
   end

data/spec/unit/confine_spec.rb

@@ -74,4 +74,20 @@ describe Puppet::Confine do
       expect(@confine.result).to eq([true, false, true, false])
     end
   end
+
+  describe "when requiring" do
+    it "does not cache failed requires when always_retry_plugins is true" do
+      Puppet[:always_retry_plugins] = true
+      Puppet::Confine.expects(:require).with('puppet/confine/osfamily').twice.raises(LoadError)
+      Puppet::Confine.test(:osfamily)
+      Puppet::Confine.test(:osfamily)
+    end
+
+    it "caches failed requires when always_retry_plugins is false" do
+      Puppet[:always_retry_plugins] = false
+      Puppet::Confine.expects(:require).with('puppet/confine/osfamily').once.raises(LoadError)
+      Puppet::Confine.test(:osfamily)
+      Puppet::Confine.test(:osfamily)
+    end
+  end
 end

data/spec/unit/context/trusted_information_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
+require 'puppet/certificate_factory'
 
 require 'puppet/context/trusted_information'
 
-describe Puppet::Context::TrustedInformation do
+describe Puppet::Context::TrustedInformation, :unless => RUBY_PLATFORM == 'java' do
   let(:key) do
     key = Puppet::SSL::Key.new("myname")
     key.generate
@@ -21,7 +22,7 @@ describe Puppet::Context::TrustedInformation do
   end
 
   let(:cert) do
-    cert = Puppet::SSL::Certificate.from_instance(Puppet::SSL::CertificateFactory.build('ca', csr, csr.content, 1))
+    cert = Puppet::SSL::Certificate.from_instance(Puppet::CertificateFactory.build('ca', csr, csr.content, 1))
 
     # The cert must be signed so that it can be successfully be DER-decoded later
     signer = Puppet::SSL::CertificateSigner.new

data/spec/unit/daemon_spec.rb

@@ -16,7 +16,7 @@ class TestClient
   end
 end
 
-describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
 
   class RecordingScheduler
@@ -35,7 +35,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
 
   let(:daemon) { Puppet::Daemon.new(pidfile, scheduler) }
 
-  before do
+  before(:each) do
+    Signal.stubs(:trap)
     daemon.stubs(:close_streams).returns nil
   end
 

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -201,7 +201,7 @@ describe "when using a hiera data provider" do
     it 'will report config path (original and resolved), data path (original and resolved), and interpolation (before and after)' do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
-        value = Puppet::Pops::Lookup.lookup('km_scope', nil, nil, nil, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('km_scope', nil, nil, nil, nil, lookup_invocation)
         expect(lookup_invocation.explainer.explain).to include(<<-EOS)
       Path "#{environmentpath}/hiera_misc/data/common.yaml"
         Original path: "common.yaml"
@@ -216,7 +216,7 @@ describe "when using a hiera data provider" do
     it 'will report that merge options was found in the lookup_options hash' do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
-        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
         expect(lookup_invocation.explainer.explain).to include("Using merge options from \"lookup_options\" hash")
       end
     end
@@ -224,7 +224,7 @@ describe "when using a hiera data provider" do
     it 'will report lookup_options details in combination with details of found value' do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true))
-        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
         expect(lookup_invocation.explainer.explain).to eq(<<EOS)
 Searching for "lookup_options"
   Global Data Provider (hiera configuration version 5)
@@ -314,7 +314,7 @@ EOS
     it 'will report config path (original and resolved), data path (original and resolved), and interpolation (before and after)' do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true, true))
-        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
         expect(lookup_invocation.explainer.explain).to eq(<<EOS)
 Merge strategy hash
   Global Data Provider (hiera configuration version 5)