puppet 6.4.4 → 6.4.5

data/spec/unit/defaults_spec.rb

@@ -139,7 +139,7 @@ describe "Defaults" do
       let(:installdir) { 'C:\Program Files\Puppet Labs\Puppet' }
 
       it 'includes user and system modules' do
-        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(installdir)
+        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(installdir)
 
         expect(
           Puppet.default_basemodulepath
@@ -147,7 +147,7 @@ describe "Defaults" do
       end
 
       it 'includes user modules if installdir fact is missing' do
-        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(nil)
+        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(nil)
 
         expect(
           Puppet.default_basemodulepath
@@ -167,7 +167,7 @@ describe "Defaults" do
       let(:installdir) { 'C:\Program Files\Puppet Labs\Puppet' }
 
       it 'includes the default vendormoduledir' do
-        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(installdir)
+        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(installdir)
 
         expect(
           Puppet.default_vendormoduledir
@@ -175,7 +175,7 @@ describe "Defaults" do
       end
 
       it 'is nil if installdir fact is missing' do
-        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(nil)
+        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(nil)
 
         expect(Puppet.default_vendormoduledir).to be_nil
       end

data/spec/unit/forge/forge_spec.rb

@@ -97,10 +97,8 @@ describe Puppet::Forge do
   def mock_proxy(port, proxy_args, result, &block)
     http = double("http client")
     proxy = double("http proxy")
-    proxy_class = double("http proxy class")
 
-    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
-    expect(proxy_class).to receive(:new).with(host, port).and_return(proxy)
+    expect(Net::HTTP).to receive(:new).with(host, port, *proxy_args).and_return(proxy)
 
     expect(proxy).to receive(:open_timeout=)
     expect(proxy).to receive(:read_timeout=)

data/spec/unit/forge/repository_spec.rb

@@ -234,10 +234,8 @@ describe Puppet::Forge::Repository do
   def mock_proxy(port, proxy_args, result, &block)
     http = double("http client")
     proxy = double("http proxy")
-    proxy_class = double("http proxy class")
 
-    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
-    expect(proxy_class).to receive(:new).with("fake.com", port).and_return(proxy)
+    expect(Net::HTTP).to receive(:new).with("fake.com", port, *proxy_args).and_return(proxy)
 
     expect(proxy).to receive(:open_timeout=)
     expect(proxy).to receive(:read_timeout=)

data/spec/unit/indirector/resource/ral_spec.rb

@@ -48,7 +48,7 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should convert ral resources into regular resources" do
-      my_resource = double("my user resource")
+      my_resource = double("my user resource", :title => "my user resource")
       my_instance = double("my user", :name => "root", :to_resource => my_resource)
 
       expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance ])
@@ -56,7 +56,7 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should filter results by name if there's a name in the key" do
-      my_resource = double("my user resource")
+      my_resource = double("my user resource", title: "my user resource")
       allow(my_resource).to receive(:to_resource).and_return(my_resource)
       allow(my_resource).to receive(:[]).with(:name).and_return("root")
 
@@ -74,11 +74,11 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should filter results by query parameters" do
-      wrong_resource = double("my user resource")
+      wrong_resource = double("my user resource", title: "my user resource")
       allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
       allow(wrong_resource).to receive(:[]).with(:name).and_return("root")
 
-      my_resource = double("wrong resource")
+      my_resource = double("wrong resource", title: "wrong resource")
       allow(my_resource).to receive(:to_resource).and_return(my_resource)
       allow(my_resource).to receive(:[]).with(:name).and_return("bob")
 

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

@@ -4,10 +4,11 @@ require 'puppet_spec/validators'
 require 'puppet/test_ca'
 
 describe Puppet::Network::HTTP::Connection do
-  let (:host) { "me" }
-  let (:port) { 54321 }
+  let (:host) { "me.example.com" }
+  let (:port) { 8140 }
+  let (:url) { "https://#{host}:#{port}/foo" }
+
   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
@@ -68,68 +69,48 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  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
+  context "when handling requests" do
+    it 'yields the response when request_get is called' do
+      stub_request(:get, url)
 
-  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
+      expect { |b|
+        subject.request_get('/foo', {}, &b)
+      }.to yield_with_args(Net::HTTPResponse)
     end
 
-    def create_connection(site, options)
-      options[:use_ssl] = site.use_ssl?
-      Puppet::Network::HTTP::Connection.new(site.host, site.port, options)
+    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)
     end
 
-    it "should redirect to the final resource location" do
-      http = double('http')
-      allow(http).to receive(:request).and_return(httpredirection, httpok)
+    it 'yields the response when request_post is called' do
+      stub_request(:post, 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
+      expect { |b|
+        subject.request_post('/foo', "param: value", &b)
+      }.to yield_with_args(Net::HTTPResponse)
+    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
 
-      conn = create_connection(site, :verify => verify)
-      conn.get('/foo')
+    def redirect_to(url)
+      { status: 302, headers: { 'Location' => url } }
     end
 
-    def expects_redirection(conn, &block)
-      http = double('http')
-      allow(http).to receive(:request).and_return(httpredirection)
+    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)
 
-      pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
-      pool
+      create_connection.get('/foo')
     end
 
     def expects_limit_exceeded(conn)
@@ -138,164 +119,157 @@ describe Puppet::Network::HTTP::Connection do
       }.to raise_error(Puppet::Network::HTTP::RedirectionLimitExceededException)
     end
 
-    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)
+    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"))
 
+      conn = create_connection(:redirect_limit => 0)
       expects_limit_exceeded(conn)
     end
 
-    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
+    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"))
 
+      conn = create_connection(:redirect_limit => 1)
       expects_limit_exceeded(conn)
     end
 
     it "should raise an exception when the redirect limit is exceeded" do
-      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
+      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(:redirect_limit => 3)
       expects_limit_exceeded(conn)
     end
   end
 
   context "when response indicates an overloaded server" do
-    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
+    def retry_after(datetime)
+      stub_request(:get, url)
+        .to_return(status: [503, 'Service Unavailable'], headers: {'Retry-After' => datetime}).then
+        .to_return(status: 200)
     end
 
     it "should return a 503 response if Retry-After is not set" do
-      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)
+      stub_request(:get, url).to_return(status: [503, 'Service Unavailable'])
 
       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
-      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)
+      stub_request(:get, url).to_return(status: [503, 'Service Unavailable'], headers: {'Retry-After' => 'foo'})
 
       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
-      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)
+      retry_after('42')
 
       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
-      httpunavailable['Retry-After'] = 'Wed, 13 Apr 2005 15:18:05 GMT'
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      retry_after('Wed, 13 Apr 2005 15:18:05 GMT')
 
       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
-      httpunavailable['Retry-After'] = '60'
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      retry_after('60')
       Puppet[:runinterval] = 30
 
-      pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
-
       expect(::Kernel).to receive(:sleep).with(30)
 
       subject.get('/foo')
     end
-  end
 
-  it "allows setting basic auth on get requests" do
-    expect_request_with_basic_auth
+    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)
 
-    subject.get('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
+      subject.get('/foo')
+    end
   end
 
-  it "allows setting basic auth on post requests" do
-    expect_request_with_basic_auth
+  context "basic auth" do
+    let(:auth) { { :user => 'user', :password => 'password' } }
+    let(:creds) { [ 'user', 'password'] }
 
-    subject.post('/path', 'data', nil, :basic_auth => { :user => 'user', :password => 'password' })
-  end
+    it "is allowed in get requests" do
+      stub_request(:get, url).with(basic_auth: creds)
 
-  it "allows setting basic auth on head requests" do
-    expect_request_with_basic_auth
+      subject.get('/foo', nil, :basic_auth => auth)
+    end
 
-    subject.head('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
-  end
+    it "is allowed in post requests" do
+      stub_request(:post, url).with(basic_auth: creds)
 
-  it "allows setting basic auth on delete requests" do
-    expect_request_with_basic_auth
+      subject.post('/foo', 'data', nil, :basic_auth => auth)
+    end
 
-    subject.delete('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
-  end
+    it "is allowed in head requests" do
+      stub_request(:head, url).with(basic_auth: creds)
 
-  it "allows setting basic auth on put requests" do
-    expect_request_with_basic_auth
+      subject.head('/foo', nil, :basic_auth => auth)
+    end
 
-    subject.put('/path', 'data', nil, :basic_auth => { :user => 'user', :password => 'password' })
-  end
+    it "is allowed in delete requests" do
+      stub_request(:delete, url).with(basic_auth: creds)
 
-  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)
+      subject.delete('/foo', nil, :basic_auth => auth)
+    end
+
+    it "is allowed in put requests" do
+      stub_request(:put, url).with(basic_auth: creds)
+
+      subject.put('/foo', 'data', nil, :basic_auth => auth)
+    end
   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 })
 
-    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
-      expect(request['User-Agent']).to eq(puppet_ua)
-    end.and_return(httpok)
+    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)
 
-    subject.get('/path')
+      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
   end
 end