puppet 6.14.0 → 6.19.0

data/spec/unit/reports/http_spec.rb

@@ -1,101 +1,119 @@
 require 'spec_helper'
 require 'puppet/reports'
 
-processor = Puppet::Reports.report(:http)
+describe Puppet::Reports.report(:http) do
+  subject { Puppet::Transaction::Report.new.extend(described_class) }
 
-describe processor do
-  subject { Puppet::Transaction::Report.new.extend(processor) }
+  let(:url) { "https://puppet.example.com/report/upload" }
+
+  before :each do
+    Puppet[:reporturl] = url
+  end
 
   describe "when setting up the connection" do
-    let(:http) { double("http") }
-    let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
+    it "raises if the connection fails" do
+      stub_request(:post, url).to_raise(Errno::ECONNREFUSED.new('Connection refused - connect(2)'))
 
-    before :each do
-      expect(http).to receive(:post).and_return(httpok)
+      expect {
+        subject.process
+      }.to raise_error(Puppet::HTTP::HTTPError, /Request to #{url} failed after .* seconds: .*Connection refused/)
     end
 
     it "configures the connection for ssl when using https" do
-      Puppet[:reporturl] = 'https://testing:8080/the/path'
+      stub_request(:post, url)
 
-      expect(Puppet::Network::HttpPool).to receive(:connection).with(
-        'testing', 8080, hash_including(ssl_context: instance_of(Puppet::SSL::SSLContext))
-      ).and_return(http)
+      expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
+        expect(http).to be_use_ssl
+        expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
+      end
 
       subject.process
     end
 
     it "does not configure the connection for ssl when using http" do
-      Puppet[:reporturl] = 'http://testing:8080/the/path'
+      Puppet[:reporturl] = 'http://puppet.example.com:8080/the/path'
+      stub_request(:post, Puppet[:reporturl])
 
-      expect(Puppet::Network::HttpPool).to receive(:connection).with(
-        'testing', 8080, use_ssl: false, ssl_context: nil
-      ).and_return(http)
+      expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
+        expect(http).to_not be_use_ssl
+      end
 
       subject.process
     end
   end
 
   describe "when making a request" do
-    let(:connection) { double("connection") }
-    let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
-    let(:options) { {:metric_id => [:puppet, :report, :http]} }
+    it "uses the path specified by the 'reporturl' setting" do
+      req = stub_request(:post, url)
+
+      subject.process
 
-    before :each do
-      expect(Puppet::Network::HttpPool).to receive(:connection).and_return(connection)
+      expect(req).to have_been_requested
     end
 
-    it "should use the path specified by the 'reporturl' setting" do
-      report_path = URI.parse(Puppet[:reporturl]).path
-      expect(connection).to receive(:post).with(report_path, anything, anything, options).and_return(httpok)
+    it "uses the username and password specified by the 'reporturl' setting" do
+      Puppet[:reporturl] = "https://user:pass@puppet.example.com/report/upload"
+
+      req = stub_request(:post, %r{/report/upload}).with(basic_auth: ['user', 'pass'])
 
       subject.process
+
+      expect(req).to have_been_requested
     end
 
-    it "should use the username and password specified by the 'reporturl' setting" do
-      Puppet[:reporturl] = "https://user:pass@myhost.mydomain:1234/report/upload"
+    it "passes metric_id options" do
+      stub_request(:post, url)
 
-      expect(connection).to receive(:post).with(anything, anything, anything,
-                                                {:metric_id => [:puppet, :report, :http],
-                                                 :basic_auth => {
-                                                   :user => 'user',
-                                                   :password => 'pass'
-                                                 }}).and_return(httpok)
+      expect(Puppet.runtime[:http]).to receive(:post).with(anything, anything, hash_including(options: hash_including(metric_id: [:puppet, :report, :http]))).and_call_original
 
       subject.process
     end
 
-    it "should give the body as the report as YAML" do
-      expect(connection).to receive(:post).with(anything, subject.to_yaml, anything, options).and_return(httpok)
+    it "passes the report as YAML" do
+      req = stub_request(:post, url).with(body: subject.to_yaml)
 
       subject.process
+
+      expect(req).to have_been_requested
     end
 
-    it "should set content-type to 'application/x-yaml'" do
-      expect(connection).to receive(:post).with(anything, anything, hash_including("Content-Type" => "application/x-yaml"), options).and_return(httpok)
+    it "sets content-type to 'application/x-yaml'" do
+      req = stub_request(:post, url).with(headers: {'Content-Type' => 'application/x-yaml'})
 
       subject.process
+
+      expect(req).to have_been_requested
     end
 
-    Net::HTTPResponse::CODE_TO_OBJ.each do |code, klass|
-      if code.to_i >= 200 and code.to_i < 300
-        it "should succeed on http code #{code}" do
-          response = klass.new('1.1', code, '')
-          expect(connection).to receive(:post).and_return(response)
+    it "doesn't log anything if the request succeeds" do
+      req = stub_request(:post, url).to_return(status: [200, "OK"])
 
-          expect(Puppet).not_to receive(:err)
-          subject.process
-        end
-      end
+      subject.process
 
-      if code.to_i >= 300 && ![301, 302, 307].include?(code.to_i)
-        it "should log error on http code #{code}" do
-          response = klass.new('1.1', code, '')
-          expect(connection).to receive(:post).and_return(response)
+      expect(req).to have_been_requested
+      expect(@logs).to eq([])
+    end
 
-          expect(Puppet).to receive(:err)
-          subject.process
-        end
-      end
+    it "follows redirects" do
+      location = {headers: {'Location' => url}}
+
+      req = stub_request(:post, url)
+              .to_return(**location, status: [301, "Moved Permanently"]).then
+              .to_return(**location, status: [302, "Found"]).then
+              .to_return(**location, status: [307, "Temporary Redirect"]).then
+              .to_return(status: [200, "OK"])
+
+      subject.process
+
+      expect(req).to have_been_requested.times(4)
+    end
+
+    it "logs an error if the request fails" do
+      stub_request(:post, url).to_return(status: [500, "Internal Server Error"])
+
+      subject.process
+
+      expect(@logs).to include(having_attributes(level: :err, message: "Unable to submit report to #{url} [500] Internal Server Error"))
     end
   end
 end

data/spec/unit/reports/store_spec.rb

@@ -6,53 +6,57 @@ require 'pathname'
 require 'tempfile'
 require 'fileutils'
 
-processor = Puppet::Reports.report(:store)
-
-describe processor do
+describe Puppet::Reports.report(:store) do
   describe "#process" do
     include PuppetSpec::Files
+
     before :each do
       Puppet[:reportdir] = File.join(tmpdir('reports'), 'reports')
-      @report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml')).extend processor
+    end
+
+    let(:report) do
+      report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
+      report.extend(described_class)
+      report
     end
 
     it "should create a report directory for the client if one doesn't exist" do
-      @report.process
+      report.process
 
-      expect(File).to be_directory(File.join(Puppet[:reportdir], @report.host))
+      expect(File).to be_directory(File.join(Puppet[:reportdir], report.host))
     end
 
     it "should write the report to the file in YAML" do
       allow(Time).to receive(:now).and_return(Time.utc(2011,01,06,12,00,00))
-      @report.process
+      report.process
 
-      expect(File.read(File.join(Puppet[:reportdir], @report.host, "201101061200.yaml"))).to eq(@report.to_yaml)
+      expect(File.read(File.join(Puppet[:reportdir], report.host, "201101061200.yaml"))).to eq(report.to_yaml)
     end
 
     it "rejects invalid hostnames" do
-      @report.host = ".."
+      report.host = ".."
       expect(Puppet::FileSystem).not_to receive(:exist?)
-      expect { @report.process }.to raise_error(ArgumentError, /Invalid node/)
+      expect { report.process }.to raise_error(ArgumentError, /Invalid node/)
     end
   end
 
   describe "::destroy" do
     it "rejects invalid hostnames" do
       expect(Puppet::FileSystem).not_to receive(:unlink)
-      expect { processor.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
+      expect { described_class.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
     end
   end
 
   describe "::validate_host" do
     ['..', 'hello/', '/hello', 'he/llo', 'hello/..', '.'].each do |node|
       it "rejects #{node.inspect}" do
-        expect { processor.validate_host(node) }.to raise_error(ArgumentError, /Invalid node/)
+        expect { described_class.validate_host(node) }.to raise_error(ArgumentError, /Invalid node/)
       end
     end
 
     ['.hello', 'hello.', '..hi', 'hi..'].each do |node|
       it "accepts #{node.inspect}" do
-        processor.validate_host(node)
+        described_class.validate_host(node)
       end
     end
   end

data/spec/unit/resource_spec.rb

@@ -283,7 +283,7 @@ describe Puppet::Resource do
     let(:scope)    { Puppet::Parser::Scope.new(compiler) }
 
     def ast_leaf(value)
-      Puppet::Parser::AST::Leaf.new({:value => value})
+      Puppet::Parser::AST::Leaf.new(value: value)
     end
 
     it "should fail when asked to set default values and it is not a parser resource" do
@@ -389,7 +389,7 @@ describe Puppet::Resource do
         context "when a value is provided" do
           let(:port_parameter) do
             Puppet::Parser::Resource::Param.new(
-              { :name => 'port', :value => '8080' }
+              name: 'port', value: '8080'
             )
           end
 
@@ -414,7 +414,7 @@ describe Puppet::Resource do
             expect_lookup('apache::port', returns: '443')
 
             rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
-              :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
+              :parameters => [Puppet::Parser::Resource::Param.new(name: 'port', value: nil)])
 
             rs.resource_type.set_resource_parameters(rs, scope)
             expect(rs[:port]).to eq('443')

data/spec/unit/rest/route_spec.rb

@@ -30,7 +30,7 @@ describe Puppet::Rest::Route do
 
       it "yields a base URL with Puppet's configured server and port when no defaults are specified" do
         Puppet[:server] = 'configured.net'
-        Puppet[:masterport] = 8140
+        Puppet[:serverport] = 8140
         fallback_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/')
         count = 0
         rval = fallback_route.with_base_url(dns_resolver) do |url|
@@ -55,9 +55,9 @@ describe Puppet::Rest::Route do
         expect(rval).to eq('Block return value')
       end
 
-      it 'falls back to :server and :masterport if nil is passed' do
+      it 'falls back to :server and :serverport if nil is passed' do
         Puppet[:server] = 'one.net'
-        Puppet[:masterport] = 111
+        Puppet[:serverport] = 111
         nil_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/',
                                             server_setting: nil,
                                             port_setting: nil)
@@ -109,7 +109,7 @@ describe Puppet::Rest::Route do
 
         it "should fall back to the default server when the block raises a SystemCallError" do
           Puppet[:server] = "testserver"
-          Puppet[:masterport] = 555
+          Puppet[:serverport] = 555
 
           count = 0
           rval = route.with_base_url(Puppet::Network::Resolver.new) do |url|

data/spec/unit/settings_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::Settings do
   include Matchers::Resource
 
   let(:main_config_file_default_location) do
-    File.join(Puppet::Util::RunMode[:master].conf_dir, "puppet.conf")
+    File.join(Puppet::Util::RunMode[:server].conf_dir, "puppet.conf")
   end
 
   let(:user_config_file_default_location) do
@@ -112,9 +112,9 @@ describe Puppet::Settings do
     #  case behaviors / uses.  However, until that time... we need to make sure that our private run_mode=
     #  setter method gets properly called during app initialization.
     it "sets the preferred run mode when initializing the app defaults" do
-      @settings.initialize_app_defaults(default_values.merge(:run_mode => :master))
+      @settings.initialize_app_defaults(default_values.merge(:run_mode => :server))
 
-      expect(@settings.preferred_run_mode).to eq(:master)
+      expect(@settings.preferred_run_mode).to eq(:server)
     end
 
     it "creates ancestor directories for all required app settings" do
@@ -326,7 +326,7 @@ describe Puppet::Settings do
     end
 
     it "should identify configured settings from the specified run mode" do
-      user_config_text = "[master]\nmyval = foo"
+      user_config_text = "[server]\nmyval = foo"
 
       allow(Puppet.features).to receive(:root?).and_return(false)
       expect(Puppet::FileSystem).to receive(:exist?).
@@ -337,7 +337,7 @@ describe Puppet::Settings do
         and_return(user_config_text).ordered
 
       @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval, nil, :master)).to be_truthy
+      expect(@settings.set_by_config?(:myval, nil, :server)).to be_truthy
     end
 
     it "should not identify configured settings from an unspecified run mode" do
@@ -382,7 +382,7 @@ describe Puppet::Settings do
 
     it "should clear the cache when the preferred_run_mode is changed" do
       expect(@settings).to receive(:flush_cache)
-      @settings.preferred_run_mode = :master
+      @settings.preferred_run_mode = :server
     end
 
     it "should not clear other values when setting getopt-specific values" do
@@ -658,6 +658,28 @@ describe Puppet::Settings do
       expect(@settings[:one]).to eq("modeval")
     end
 
+    [:master, :server].each do |run_mode|
+      describe "when run mode is '#{run_mode}'" do
+        before(:each) { @settings.preferred_run_mode = run_mode }
+
+        it "returns values set in the 'master' section if the 'server' section does not exist" do
+          text = "[main]\none = mainval\n[master]\none = modeval\n"
+          allow(@settings).to receive(:read_file).and_return(text)
+          @settings.send(:parse_config_files)
+
+          expect(@settings[:one]).to eq("modeval")
+        end
+
+        it "prioritizes values set in the 'server' section if set" do
+          text = "[main]\none = mainval\n[server]\none = serverval\n[master]\none = masterval\n"
+          allow(@settings).to receive(:read_file).and_return(text)
+          @settings.send(:parse_config_files)
+
+          expect(@settings[:one]).to eq("serverval")
+        end
+      end
+    end
+
     it "should not return values outside of its search path" do
       text = "[other]\none = oval\n"
       allow(@settings).to receive(:read_file).and_return(text)
@@ -854,10 +876,10 @@ describe Puppet::Settings do
         default_values[key] = 'default value'
       end
       @settings.define_settings :main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS
-      @settings.define_settings :master, :myfile => { :type => :file, :default => make_absolute("/myfile"), :desc => "a" }
+      @settings.define_settings :server, :myfile => { :type => :file, :default => make_absolute("/myfile"), :desc => "a" }
 
       otherfile = make_absolute("/other/file")
-      text = "[master]
+      text = "[server]
       myfile = #{otherfile} {mode = 664}
       "
       expect(@settings).to receive(:read_file).and_return(text)
@@ -866,9 +888,9 @@ describe Puppet::Settings do
       expect(@settings.preferred_run_mode).to eq(:user)
       @settings.send(:parse_config_files)
 
-      # change app run_mode to master
-      @settings.initialize_app_defaults(default_values.merge(:run_mode => :master))
-      expect(@settings.preferred_run_mode).to eq(:master)
+      # change app run_mode to server
+      @settings.initialize_app_defaults(default_values.merge(:run_mode => :server))
+      expect(@settings.preferred_run_mode).to eq(:server)
 
       # initializing the app should have reloaded the metadata based on run_mode
       expect(@settings[:myfile]).to eq(otherfile)
@@ -884,9 +906,9 @@ describe Puppet::Settings do
       file = make_absolute("/file")
       default_mode = "0600"
       @settings.define_settings :main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS
-      @settings.define_settings :master, :myfile => { :type => :file, :default => file, :desc => "a", :mode => default_mode }
+      @settings.define_settings :server, :myfile => { :type => :file, :default => file, :desc => "a", :mode => default_mode }
 
-      text = "[master]
+      text = "[server]
       myfile = #{file}/foo
       [agent]
       myfile = #{file} {mode = 664}
@@ -897,9 +919,9 @@ describe Puppet::Settings do
       expect(@settings.preferred_run_mode).to eq(:user)
       @settings.send(:parse_config_files)
 
-      # change app run_mode to master
-      @settings.initialize_app_defaults(default_values.merge(:run_mode => :master))
-      expect(@settings.preferred_run_mode).to eq(:master)
+      # change app run_mode to server
+      @settings.initialize_app_defaults(default_values.merge(:run_mode => :server))
+      expect(@settings.preferred_run_mode).to eq(:server)
 
       # initializing the app should have reloaded the metadata based on run_mode
       expect(@settings[:myfile]).to eq("#{file}/foo")
@@ -1900,18 +1922,18 @@ describe Puppet::Settings do
     end
 
     it "should set preferred run mode from --run_mode <foo> string without error" do
-      args = ["--run_mode", "master"]
-      expect(settings).not_to receive(:handlearg).with("--run_mode", "master")
+      args = ["--run_mode", "server"]
+      expect(settings).not_to receive(:handlearg).with("--run_mode", "server")
       expect { settings.send(:parse_global_options, args) } .to_not raise_error
-      expect(Puppet.settings.preferred_run_mode).to eq(:master)
+      expect(Puppet.settings.preferred_run_mode).to eq(:server)
       expect(args.empty?).to eq(true)
     end
 
     it "should set preferred run mode from --run_mode=<foo> string without error" do
-      args = ["--run_mode=master"]
-      expect(settings).not_to receive(:handlearg).with("--run_mode", "master")
+      args = ["--run_mode=server"]
+      expect(settings).not_to receive(:handlearg).with("--run_mode", "server")
       expect { settings.send(:parse_global_options, args) }.to_not raise_error
-      expect(Puppet.settings.preferred_run_mode).to eq(:master)
+      expect(Puppet.settings.preferred_run_mode).to eq(:server)
       expect(args.empty?).to eq(true)
     end
   end

data/spec/unit/ssl/host_spec.rb

@@ -51,8 +51,10 @@ describe Puppet::SSL::Host, if: !Puppet::Util::Platform.jruby? do
       allow_any_instance_of(Puppet::SSL::Host).to receive(:generate)
     end
 
-    it "should have a method for producing an instance to manage the local host's keys" do
-      expect(Puppet::SSL::Host).to respond_to(:localhost)
+    it "is deprecated" do
+      Puppet::SSL::Host.localhost
+
+      expect(@logs).to include(an_object_having_attributes(message: /Puppet::SSL::Host is deprecated/))
     end
 
     it "should allow to reset localhost" do