puppet 6.4.5-x86-mingw32 → 6.5.0-x86-mingw32

data/spec/unit/network/http/connection_spec.rb

@@ -4,11 +4,10 @@ require 'puppet_spec/validators'
 require 'puppet/test_ca'
 
 describe Puppet::Network::HTTP::Connection do
-  let (:host) { "me.example.com" }
-  let (:port) { 8140 }
-  let (:url) { "https://#{host}:#{port}/foo" }
-
+  let (:host) { "me" }
+  let (:port) { 54321 }
   subject { Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator) }
+  let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
   context "when providing HTTP connections" do
     context "when initializing http instances" do
@@ -69,48 +68,68 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  context "when handling requests" do
-    it 'yields the response when request_get is called' do
-      stub_request(:get, url)
-
-      expect { |b|
-        subject.request_get('/foo', {}, &b)
-      }.to yield_with_args(Net::HTTPResponse)
+  context "when handling requests", :vcr do
+    let (:host) { "my-server" }
+    let (:port) { 8140 }
+    let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
+
+    { :request_get  => {},
+      :request_head => {},
+      :request_post => "param: value" }.each do |method,body|
+      context "##{method}" do
+        it "should yield to the block" do
+          allow_any_instance_of(Net::HTTP).to receive(method) do |_, *_, &block|
+            block.call()
+            httpok
+          end
+
+          block_executed = false
+          subject.send(method, "/foo", body) do |response|
+            block_executed = true
+          end
+          expect(block_executed).to eq(true)
+        end
+      end
     end
+  end
 
-    it 'yields the response when request_head is called' do
-      stub_request(:head, url)
-
-      expect { |b|
-        subject.request_head('/foo', {}, &b)
-      }.to yield_with_args(Net::HTTPResponse)
+  context "when response is a redirect" do
+    let (:site)       { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
+    let (:other_site) { Puppet::Network::HTTP::Site.new('http', 'redirected', 9292) }
+    let (:other_path) { "other-path" }
+    let (:verify) { Puppet::SSL::Validator.no_validator }
+    let (:subject) { Puppet::Network::HTTP::Connection.new(site.host, site.port, :use_ssl => false, :verify => verify) }
+    let (:httpredirection) do
+      response = Net::HTTPFound.new('1.1', 302, 'Moved Temporarily')
+      response['location'] = "#{other_site.addr}/#{other_path}"
+      allow(response).to receive(:read_body).and_return("This resource has moved")
+      response
     end
 
-    it 'yields the response when request_post is called' do
-      stub_request(:post, url)
-
-      expect { |b|
-        subject.request_post('/foo', "param: value", &b)
-      }.to yield_with_args(Net::HTTPResponse)
+    def create_connection(site, options)
+      options[:use_ssl] = site.use_ssl?
+      Puppet::Network::HTTP::Connection.new(site.host, site.port, options)
     end
-  end
 
-  context "when response is a redirect" do
-    def create_connection(options = {})
-      options[:use_ssl] = false
-      options[:verify] = Puppet::SSL::Validator.no_validator
-      Puppet::Network::HTTP::Connection.new(host, port, options)
-    end
+    it "should redirect to the final resource location" do
+      http = double('http')
+      allow(http).to receive(:request).and_return(httpredirection, httpok)
 
-    def redirect_to(url)
-      { status: 302, headers: { 'Location' => url } }
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http).ordered
+      expect(pool).to receive(:with_connection).with(other_site, anything).and_yield(http).ordered
+
+      conn = create_connection(site, :verify => verify)
+      conn.get('/foo')
     end
 
-    it "should follow the redirect to the final resource location" do
-      stub_request(:get, "http://me.example.com:8140/foo").to_return(redirect_to("http://me.example.com:8140/bar"))
-      stub_request(:get, "http://me.example.com:8140/bar").to_return(status: 200)
+    def expects_redirection(conn, &block)
+      http = double('http')
+      allow(http).to receive(:request).and_return(httpredirection)
 
-      create_connection.get('/foo')
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+      pool
     end
 
     def expects_limit_exceeded(conn)
@@ -119,157 +138,164 @@ describe Puppet::Network::HTTP::Connection do
       }.to raise_error(Puppet::Network::HTTP::RedirectionLimitExceededException)
     end
 
-    it "should not follow any redirects when the limit is 0" do
-      stub_request(:get, "http://me.example.com:8140/").to_return(redirect_to("http://me.example.com:8140/foo"))
+    it "should not redirect when the limit is 0" do
+      conn = create_connection(site, :verify => verify, :redirect_limit => 0)
+
+      pool = expects_redirection(conn)
+      expect(pool).not_to receive(:with_connection).with(other_site, anything)
 
-      conn = create_connection(:redirect_limit => 0)
       expects_limit_exceeded(conn)
     end
 
-    it "should follow the redirect once" do
-      stub_request(:get, "http://me.example.com:8140/").to_return(redirect_to("http://me.example.com:8140/foo"))
-      stub_request(:get, "http://me.example.com:8140/foo").to_return(redirect_to("http://me.example.com:8140/bar"))
+    it "should redirect only once" do
+      conn = create_connection(site, :verify => verify, :redirect_limit => 1)
+
+      pool = expects_redirection(conn)
+      expect(pool).to receive(:with_connection).with(other_site, anything).once
 
-      conn = create_connection(:redirect_limit => 1)
       expects_limit_exceeded(conn)
     end
 
     it "should raise an exception when the redirect limit is exceeded" do
-      stub_request(:get, "http://me.example.com:8140/").to_return(redirect_to("http://me.example.com:8140/foo"))
-      stub_request(:get, "http://me.example.com:8140/foo").to_return(redirect_to("http://me.example.com:8140/bar"))
-      stub_request(:get, "http://me.example.com:8140/bar").to_return(redirect_to("http://me.example.com:8140/baz"))
-      stub_request(:get, "http://me.example.com:8140/baz").to_return(redirect_to("http://me.example.com:8140/qux"))
+      conn = create_connection(site, :verify => verify, :redirect_limit => 3)
+
+      pool = expects_redirection(conn)
+      expect(pool).to receive(:with_connection).with(other_site, anything).exactly(3).times
 
-      conn = create_connection(:redirect_limit => 3)
       expects_limit_exceeded(conn)
     end
   end
 
   context "when response indicates an overloaded server" do
-    def retry_after(datetime)
-      stub_request(:get, url)
-        .to_return(status: [503, 'Service Unavailable'], headers: {'Retry-After' => datetime}).then
-        .to_return(status: 200)
+    let(:http) { double('http') }
+    let(:site) { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
+    let(:verify) { Puppet::SSL::Validator.no_validator }
+    let(:httpunavailable) { Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable') }
+
+    subject { Puppet::Network::HTTP::Connection.new(site.host, site.port, :use_ssl => false, :verify => verify) }
+
+    context "when parsing Retry-After headers" do
+      # Private method. Create a reference that can be called by tests.
+      let(:header_parser) { subject.method(:parse_retry_after_header) }
+
+      it "returns 0 when parsing a RFC 2822 date that has passed" do
+        test_date = 'Wed, 13 Apr 2005 15:18:05 GMT'
+
+        expect(header_parser.call(test_date)).to eq(0)
+      end
     end
 
     it "should return a 503 response if Retry-After is not set" do
-      stub_request(:get, url).to_return(status: [503, 'Service Unavailable'])
+      allow(http).to receive(:request).and_return(httpunavailable)
+
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
 
       result = subject.get('/foo')
-      expect(result.code).to eq("503")
+
+      expect(result.code).to eq(503)
     end
 
     it "should return a 503 response if Retry-After is not convertible to an Integer or RFC 2822 Date" do
-      stub_request(:get, url).to_return(status: [503, 'Service Unavailable'], headers: {'Retry-After' => 'foo'})
+      httpunavailable['Retry-After'] = 'foo'
+      allow(http).to receive(:request).and_return(httpunavailable)
+
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
 
       result = subject.get('/foo')
-      expect(result.code).to eq("503")
+
+      expect(result.code).to eq(503)
     end
 
     it "should sleep and retry if Retry-After is an Integer" do
-      retry_after('42')
+      httpunavailable['Retry-After'] = '42'
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
+
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
 
       expect(::Kernel).to receive(:sleep).with(42)
 
       result = subject.get('/foo')
-      expect(result.code).to eq("200")
+
+      expect(result.code).to eq(200)
     end
 
     it "should sleep and retry if Retry-After is an RFC 2822 Date" do
-      retry_after('Wed, 13 Apr 2005 15:18:05 GMT')
+      httpunavailable['Retry-After'] = 'Wed, 13 Apr 2005 15:18:05 GMT'
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
 
       now = DateTime.new(2005, 4, 13, 8, 17, 5, '-07:00')
       allow(DateTime).to receive(:now).and_return(now)
 
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
+
       expect(::Kernel).to receive(:sleep).with(60)
 
       result = subject.get('/foo')
-      expect(result.code).to eq("200")
+
+      expect(result.code).to eq(200)
     end
 
     it "should sleep for no more than the Puppet runinterval" do
-      retry_after('60')
+      httpunavailable['Retry-After'] = '60'
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
       Puppet[:runinterval] = 30
 
-      expect(::Kernel).to receive(:sleep).with(30)
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
 
-      subject.get('/foo')
-    end
-
-    it "should sleep for 0 seconds if the RFC 2822 date has past" do
-      retry_after('Wed, 13 Apr 2005 15:18:05 GMT')
-
-      expect(::Kernel).to receive(:sleep).with(0)
+      expect(::Kernel).to receive(:sleep).with(30)
 
       subject.get('/foo')
     end
   end
 
-  context "basic auth" do
-    let(:auth) { { :user => 'user', :password => 'password' } }
-    let(:creds) { [ 'user', 'password'] }
+  it "allows setting basic auth on get requests" do
+    expect_request_with_basic_auth
 
-    it "is allowed in get requests" do
-      stub_request(:get, url).with(basic_auth: creds)
+    subject.get('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
 
-      subject.get('/foo', nil, :basic_auth => auth)
-    end
+  it "allows setting basic auth on post requests" do
+    expect_request_with_basic_auth
 
-    it "is allowed in post requests" do
-      stub_request(:post, url).with(basic_auth: creds)
+    subject.post('/path', 'data', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
 
-      subject.post('/foo', 'data', nil, :basic_auth => auth)
-    end
+  it "allows setting basic auth on head requests" do
+    expect_request_with_basic_auth
 
-    it "is allowed in head requests" do
-      stub_request(:head, url).with(basic_auth: creds)
+    subject.head('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
 
-      subject.head('/foo', nil, :basic_auth => auth)
-    end
+  it "allows setting basic auth on delete requests" do
+    expect_request_with_basic_auth
 
-    it "is allowed in delete requests" do
-      stub_request(:delete, url).with(basic_auth: creds)
+    subject.delete('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
 
-      subject.delete('/foo', nil, :basic_auth => auth)
-    end
+  it "allows setting basic auth on put requests" do
+    expect_request_with_basic_auth
 
-    it "is allowed in put requests" do
-      stub_request(:put, url).with(basic_auth: creds)
+    subject.put('/path', 'data', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
 
-      subject.put('/foo', 'data', nil, :basic_auth => auth)
-    end
+  def expect_request_with_basic_auth
+    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
+      expect(request['authorization']).to match(/^Basic/)
+    end.and_return(httpok)
   end
 
   it "sets HTTP User-Agent header" do
     puppet_ua = "Puppet/#{Puppet.version} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
-    stub_request(:get, url).with(headers: { 'User-Agent' => puppet_ua })
 
-    subject.get('/foo')
-  end
-
-  describe 'connection request errors' do
-    it "logs and raises generic http errors" do
-      generic_error = Net::HTTPError.new('generic error', double("response"))
-      stub_request(:get, url).to_raise(generic_error)
+    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
+      expect(request['User-Agent']).to eq(puppet_ua)
+    end.and_return(httpok)
 
-      expect(Puppet).to receive(:log_exception).with(anything, /^.*failed: generic error$/)
-      expect { subject.get('/foo') }.to raise_error(generic_error)
-    end
-
-    it "logs and raises timeout errors" do
-      timeout_error = Timeout::Error.new
-      stub_request(:get, url).to_raise(timeout_error)
-
-      expect(Puppet).to receive(:log_exception).with(anything, /^.*timed out after .* seconds$/)
-      expect { subject.get('/foo') }.to raise_error(timeout_error)
-    end
-
-    it "logs and raises eof errors" do
-      eof_error = EOFError
-      stub_request(:get, url).to_raise(eof_error)
-
-      expect(Puppet).to receive(:log_exception).with(anything, /^.*interrupted after .* seconds$/)
-      expect { subject.get('/foo') }.to raise_error(eof_error)
-    end
+    subject.get('/path')
   end
 end

data/spec/unit/network/http/factory_spec.rb

@@ -43,11 +43,10 @@ describe Puppet::Network::HTTP::Factory do
   context "proxy settings" do
     let(:proxy_host) { 'myhost' }
     let(:proxy_port) { 432 }
-    let(:proxy_user) { 'mo' }
-    let(:proxy_pass) { 'password' }
 
-    it "should not set a proxy if the http_proxy_host setting is 'none'" do
+    it "should not set a proxy if the value is 'none'" do
       Puppet[:http_proxy_host] = 'none'
+      expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
@@ -56,18 +55,7 @@ describe Puppet::Network::HTTP::Factory do
     it 'should not set a proxy if a no_proxy env var matches the destination' do
       Puppet[:http_proxy_host] = proxy_host
       Puppet[:http_proxy_port] = proxy_port
-      Puppet::Util.withenv('NO_PROXY' => site.host) do
-        conn = create_connection(site)
-
-        expect(conn.proxy_address).to be_nil
-        expect(conn.proxy_port).to be_nil
-      end
-    end
-
-    it 'should not set a proxy if the no_proxy setting matches the destination' do
-      Puppet[:http_proxy_host] = proxy_host
-      Puppet[:http_proxy_port] = proxy_port
-      Puppet[:no_proxy] = site.host
+      expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(true)
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
@@ -76,6 +64,7 @@ describe Puppet::Network::HTTP::Factory do
 
     it 'sets proxy_address' do
       Puppet[:http_proxy_host] = proxy_host
+      expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
       conn = create_connection(site)
 
       expect(conn.proxy_address).to eq(proxy_host)
@@ -84,22 +73,11 @@ describe Puppet::Network::HTTP::Factory do
     it 'sets proxy address and port' do
       Puppet[:http_proxy_host] = proxy_host
       Puppet[:http_proxy_port] = proxy_port
+      expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
       conn = create_connection(site)
 
       expect(conn.proxy_port).to eq(proxy_port)
     end
-
-    it 'sets proxy user and password' do
-      Puppet[:http_proxy_host] = proxy_host
-      Puppet[:http_proxy_port] = proxy_port
-      Puppet[:http_proxy_user] = proxy_user
-      Puppet[:http_proxy_password] = proxy_pass
-
-      conn = create_connection(site)
-
-      expect(conn.proxy_user).to eq(proxy_user)
-      expect(conn.proxy_pass).to eq(proxy_pass)
-    end
   end
 
   context 'socket timeouts' do

data/spec/unit/parser/scope_spec.rb

@@ -680,15 +680,5 @@ describe Puppet::Parser::Scope do
       @scope.setvar("orange", :undef)
       expect(@scope.to_hash).to eq({'pear' => :green, 'apple' => :red })
     end
-
-    it "should not delete values that are :undef in inner scope when include_undef is true" do
-      @scope.new_ephemeral true
-      @scope.setvar("orange", :tangerine)
-      @scope.setvar("pear", :green)
-      @scope.new_ephemeral true
-      @scope.setvar("apple", :red)
-      @scope.setvar("orange", :undef)
-      expect(@scope.to_hash(true, true)).to eq({'pear' => :green, 'apple' => :red, 'orange' => :undef })
-    end
   end
 end

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -478,26 +478,21 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       }.each do |source, coerced_val|
           it "should warn about numeric coercion in '#{source}' when strict = warning" do
             Puppet[:strict] = :warning
-            expect(Puppet::Pops::Evaluator::Runtime3Support::EvaluationError).not_to receive(:new)
             collect_notices(source)
             expect(warnings).to include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
           end
 
           it "should not warn about numeric coercion in '#{source}' if strict = off" do
             Puppet[:strict] = :off
-            expect(Puppet::Pops::Evaluator::Runtime3Support::EvaluationError).not_to receive(:new)
             collect_notices(source)
             expect(warnings).to_not include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
           end
 
         it "should error when finding numeric coercion in '#{source}' if strict = error" do
           Puppet[:strict] = :error
-          expect {
-            parser.evaluate_string(scope, source, __FILE__)
-          }.to raise_error {|error|
-            expect(error.message).to match(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
-            expect(error.backtrace.first).to match(/runtime3_support\.rb.+optionally_fail/)
-          }
+          expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(
+            /The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/
+            )
         end
       end