puppet 6.11.1-x64-mingw32 → 6.16.0-x64-mingw32

data/spec/unit/http/external_client_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+require 'puppet/http'
+
+# Simple "external" client to make get & post requests. This is used
+# to test the old HTTP API, such as requiring use_ssl and basic_auth
+# to be passed as options.
+class Puppet::HTTP::TestExternal
+  def initialize(host, port, options = {})
+    @host = host
+    @port = port
+    @options = options
+    @factory = Puppet::Network::HTTP::Factory.new
+  end
+
+  def get(path, headers = {}, options = {})
+    request = Net::HTTP::Get.new(path, headers)
+    do_request(request, options)
+  end
+
+  def post(path, data, headers = nil, options = {})
+    request = Net::HTTP::Post.new(path, headers)
+    do_request(request, options)
+  end
+
+  def do_request(request, options)
+    if options[:basic_auth]
+      request.basic_auth(options[:basic_auth][:user], options[:basic_auth][:password])
+    end
+
+    site = Puppet::Network::HTTP::Site.new(@options[:use_ssl] ? 'https' : 'http', @host, @port)
+    http = @factory.create_connection(site)
+    http.start
+    begin
+      http.request(request)
+    ensure
+      http.finish
+    end
+  end
+end
+
+describe Puppet::HTTP::ExternalClient do
+  let(:uri) { URI.parse('https://www.example.com') }
+  let(:http_client_class) { Puppet::HTTP::TestExternal }
+  let(:client) { described_class.new(http_client_class) }
+  let(:credentials) { ['user', 'pass'] }
+
+  context "for GET requests" do
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:get, uri).with(query: "foo=bar%3Dbaz")
+
+      client.get(uri, params: {:foo => "bar=baz"})
+    end
+
+    it "fails if a user passes in an invalid param type" do
+      environment = Puppet::Node::Environment.create(:testing, [])
+
+      expect{client.get(uri, params: {environment: environment})}.to raise_error(Puppet::HTTP::SerializationError, /HTTP REST queries cannot handle values of type/)
+    end
+
+    it "returns the response" do
+      stub_request(:get, uri)
+
+      response = client.get(uri)
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "returns the entire response body" do
+      stub_request(:get, uri).to_return(body: "abc")
+
+      expect(client.get(uri).body).to eq("abc")
+    end
+
+    it "streams the response body when a block is given" do
+      stub_request(:get, uri).to_return(body: "abc")
+
+      io = StringIO.new
+      client.get(uri) do |response|
+        response.read_body do |data|
+          io.write(data)
+        end
+      end
+
+      expect(io.string).to eq("abc")
+    end
+
+    context 'when connecting' do
+      it 'accepts an ssl context' do
+        stub_request(:get, uri).to_return(body: "abc")
+
+        other_context = Puppet::SSL::SSLContext.new
+
+        client.get(uri, options: {ssl_context: other_context})
+      end
+
+      it 'accepts include_system_store' do
+        stub_request(:get, uri).to_return(body: "abc")
+
+        client.get(uri, options: {include_system_store: true})
+      end
+    end
+  end
+
+  context "for POST requests" do
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:post, "https://www.example.com").with(query: "foo=bar%3Dbaz")
+
+      client.post(uri, "", params: {:foo => "bar=baz"}, headers: {'Content-Type' => 'text/plain'})
+    end
+
+    it "returns the response" do
+      stub_request(:post, uri)
+
+      response = client.post(uri, "", headers: {'Content-Type' => 'text/plain'})
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "sets content-type for the body" do
+      stub_request(:post, uri).with(headers: {"Content-Type" => "text/plain"})
+
+      client.post(uri, "hello", headers: {'Content-Type' => 'text/plain'})
+    end
+
+    it "streams the response body when a block is given" do
+      stub_request(:post, uri).to_return(body: "abc")
+
+      io = StringIO.new
+      client.post(uri, "", headers: {'Content-Type' => 'text/plain'}) do |response|
+        response.read_body do |data|
+          io.write(data)
+        end
+      end
+
+      expect(io.string).to eq("abc")
+    end
+
+    it 'raises an ArgumentError if `body` is missing' do
+      expect {
+        client.post(uri, nil, headers: {'Content-Type' => 'text/plain'})
+      }.to raise_error(ArgumentError, /'post' requires a string 'body' argument/)
+    end
+
+    context 'when connecting' do
+      it 'accepts an ssl context' do
+        stub_request(:post, uri)
+
+        other_context = Puppet::SSL::SSLContext.new
+
+        client.post(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: other_context})
+      end
+
+      it 'accepts include_system_store' do
+        stub_request(:post, uri)
+
+        client.post(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {include_system_store: true})
+      end
+    end
+  end
+
+  context "Basic Auth" do
+    it "submits credentials for GET requests" do
+      stub_request(:get, uri).with(basic_auth: credentials)
+
+      client.get(uri, options: {basic_auth: {user: 'user', password: 'pass'}})
+    end
+
+    it "submits credentials for POST requests" do
+      stub_request(:post, uri).with(basic_auth: credentials)
+
+      client.post(uri, "", options: {content_type: 'text/plain', basic_auth: {user: 'user', password: 'pass'}})
+    end
+
+    it "returns response containing access denied" do
+      stub_request(:get, uri).with(basic_auth: credentials).to_return(status: [403, "Ye Shall Not Pass"])
+
+      response = client.get(uri, options: { basic_auth: {user: 'user', password: 'pass'}})
+      expect(response.code).to eq(403)
+      expect(response.reason).to eq("Ye Shall Not Pass")
+      expect(response).to_not be_success
+    end
+
+    it 'includes basic auth if user is nil' do
+      stub_request(:get, uri).with do |req|
+        expect(req.headers).to include('Authorization')
+      end
+
+      client.get(uri, options: {basic_auth: {user: nil, password: 'pass'}})
+    end
+
+    it 'includes basic auth if password is nil' do
+      stub_request(:get, uri).with do |req|
+        expect(req.headers).to include('Authorization')
+      end
+
+      client.get(uri, options: {basic_auth: {user: 'user', password: nil}})
+    end
+  end
+end

data/spec/unit/http/resolver_spec.rb

@@ -9,22 +9,92 @@ describe Puppet::HTTP::Resolver do
   let(:uri) { URI.parse('https://www.example.com') }
 
   context 'when resolving using settings' do
-    let(:subject) { Puppet::HTTP::Resolver::Settings.new }
+    let(:subject) { Puppet::HTTP::Resolver::Settings.new(client) }
 
-    it 'yields a service based on the current ca_server and ca_port settings' do
+    it 'returns a service based on the current ca_server and ca_port settings' do
       Puppet[:ca_server] = 'ca.example.com'
       Puppet[:ca_port] = 8141
 
-      subject.resolve(session, :ca) do |service|
-        expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
-        expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
-      end
+      service = subject.resolve(session, :ca)
+      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
+      expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
+    end
+  end
+
+  context 'when resolving using server_list' do
+    let(:subject) { Puppet::HTTP::Resolver::ServerList.new(client, server_list_setting: Puppet.settings.setting(:server_list), default_port: 8142, services: Puppet::HTTP::Service::SERVICE_NAMES) }
+
+    before :each do
+      Puppet[:server_list] = 'ca.example.com:8141,apple.example.com'
+    end
+
+    it 'returns a service based on the current server_list setting' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 200)
+
+      service = subject.resolve(session, :ca)
+      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
+      expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
+    end
+
+    it 'returns a service based on the current server_list setting if the server returns any success codes' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 202)
+
+      service = subject.resolve(session, :ca)
+      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
+      expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
+    end
+
+    it 'logs unsuccessful HTTP 500 responses' do
+      Puppet[:log_level] = "debug"
+
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: [500, 'Internal Server Error'])
+      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 200)
+
+      subject.resolve(session, :ca)
+
+      expect(@logs.map(&:message)).to include(/Puppet server ca.example.com:8141 is unavailable: 500 Internal Server Error/)
+    end
+
+    it 'fails if no servers in server_list are accessible' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 503)
+      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 503)
+
+      expect { subject.resolve(session, :ca) }.to raise_error(Puppet::Error, /^Could not select a functional puppet master from server_list:/)
+    end
+
+    it 'cycles through server_list until a valid server is found' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 503)
+      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 200)
+
+      service = subject.resolve(session, :ca)
+      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
+      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet-ca/v1")
+    end
+
+    it 'resolves once per session' do
+      failed = stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 503)
+      passed = stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 200)
+
+      service = subject.resolve(session, :puppet)
+      expect(service).to be_a(Puppet::HTTP::Service::Compiler)
+      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
+
+      service = subject.resolve(session, :fileserver)
+      expect(service).to be_a(Puppet::HTTP::Service::FileServer)
+      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
+
+      service = subject.resolve(session, :report)
+      expect(service).to be_a(Puppet::HTTP::Service::Report)
+      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
+
+      expect(failed).to have_been_requested
+      expect(passed).to have_been_requested
     end
   end
 
   context 'when resolving using SRV' do
     let(:dns) { double('dns') }
-    let(:subject) { Puppet::HTTP::Resolver::SRV.new(domain: 'example.com', dns: dns) }
+    let(:subject) { Puppet::HTTP::Resolver::SRV.new(client, domain: 'example.com', dns: dns) }
 
     def stub_srv(host, port)
       srv = Resolv::DNS::Resource::IN::SRV.new(0, 0, port, host)
@@ -33,13 +103,12 @@ describe Puppet::HTTP::Resolver do
       allow(dns).to receive(:getresources).with("_x-puppet-ca._tcp.example.com", Resolv::DNS::Resource::IN::SRV).and_return([srv])
     end
 
-    it 'yields a service based on an SRV record' do
+    it 'returns a service based on an SRV record' do
       stub_srv('ca1.example.com', 8142)
 
-      subject.resolve(session, :ca) do |service|
-        expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
-        expect(service.url.to_s).to eq("https://ca1.example.com:8142/puppet-ca/v1")
-      end
+      service = subject.resolve(session, :ca)
+      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
+      expect(service.url.to_s).to eq("https://ca1.example.com:8142/puppet-ca/v1")
     end
   end
 end

data/spec/unit/http/response_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'puppet/http'
+
+describe Puppet::HTTP::Response do
+  let(:uri) { URI.parse('https://www.example.com') }
+  let(:client) { Puppet::HTTP::Client.new }
+
+  it "returns the request URL" do
+    stub_request(:get, uri)
+
+    response = client.get(uri)
+    expect(response.url).to eq(uri)
+  end
+
+  it "returns the HTTP code" do
+    stub_request(:get, uri)
+
+    response = client.get(uri)
+    expect(response.code).to eq(200)
+  end
+
+  it "returns the HTTP reason string" do
+    stub_request(:get, uri).to_return(status: [418, "I'm a teapot"])
+
+    response = client.get(uri)
+    expect(response.reason).to eq("I'm a teapot")
+  end
+
+  it "returns the response body" do
+    stub_request(:get, uri).to_return(status: 200, body: "I'm the body")
+
+    response = client.get(uri)
+    expect(response.body).to eq("I'm the body")
+  end
+
+  it "streams the response body" do
+    stub_request(:get, uri).to_return(status: 200, body: "I'm the streaming body")
+
+    content = StringIO.new
+    client.get(uri) do |response|
+      response.read_body do |data|
+        content << data
+      end
+    end
+    expect(content.string).to eq("I'm the streaming body")
+  end
+
+  it "raises if a block isn't given when streaming" do
+    stub_request(:get, uri).to_return(status: 200, body: "")
+
+    expect {
+      client.get(uri) do |response|
+        response.read_body
+      end
+    }.to raise_error(Puppet::HTTP::HTTPError, %r{Request to https://www.example.com failed after .* seconds: A block is required})
+  end
+
+  it "returns success for all 2xx codes" do
+    stub_request(:get, uri).to_return(status: 202)
+
+    expect(client.get(uri)).to be_success
+  end
+
+  it "returns a header value" do
+    stub_request(:get, uri).to_return(status: 200, headers: { 'Content-Encoding' => 'gzip' })
+
+    expect(client.get(uri)['Content-Encoding']).to eq('gzip')
+  end
+end

data/spec/unit/http/service/ca_spec.rb

@@ -5,18 +5,78 @@ require 'puppet/http'
 describe Puppet::HTTP::Service::Ca do
   let(:ssl_context) { Puppet::SSL::SSLContext.new }
   let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
-  let(:base_url) { URI.parse('https://www.example.com') }
-  let(:subject) { described_class.new(client, base_url) }
+  let(:session) { Puppet::HTTP::Session.new(client, []) }
+  let(:subject) { client.create_session.route_to(:ca) }
+
+  before :each do
+    Puppet[:ca_server] = 'www.example.com'
+    Puppet[:ca_port] = 443
+  end
+
+  context 'when making requests' do
+    let(:uri) {"https://www.example.com:443/puppet-ca/v1/certificate/ca"}
+
+    it 'includes default HTTP headers' do
+      stub_request(:get, uri).with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        expect(request.headers).to_not include('X-Puppet-Profiling')
+      end
+
+      subject.get_certificate('ca')
+    end
+  end
+
+  context 'when routing to the CA service' do
+    let(:cert) { cert_fixture('ca.pem') }
+    let(:pem) { cert.to_pem }
+
+    it 'defaults the server and port based on settings' do
+      Puppet[:ca_server] = 'ca.example.com'
+      Puppet[:ca_port] = 8141
+
+      stub_request(:get, "https://ca.example.com:8141/puppet-ca/v1/certificate/ca").to_return(body: pem)
+
+      subject.get_certificate('ca')
+    end
+
+    it 'fallbacks to server and masterport' do
+      Puppet[:ca_server] = nil
+      Puppet[:ca_port] = nil
+      Puppet[:server] = 'ca2.example.com'
+      Puppet[:masterport] = 8142
+
+      stub_request(:get, "https://ca2.example.com:8142/puppet-ca/v1/certificate/ca").to_return(body: pem)
+
+      subject.get_certificate('ca')
+    end
+  end
 
   context 'when getting certificates' do
     let(:cert) { cert_fixture('ca.pem') }
     let(:pem) { cert.to_pem }
-    let(:url) { "https://www.example.com/certificate/ca" }
+    let(:url) { "https://www.example.com/puppet-ca/v1/certificate/ca" }
+
+    it 'includes headers set via the :http_extra_headers and :profile settings' do
+      stub_request(:get, url).with(headers: {'Example-Header' => 'real-thing', 'another' => 'thing', 'X-Puppet-Profiling' => 'true'})
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      subject.get_certificate('ca')
+    end
 
     it 'gets a certificate from the "certificate" endpoint' do
       stub_request(:get, url).to_return(body: pem)
 
-      expect(subject.get_certificate('ca')).to eq(pem)
+      _, body = subject.get_certificate('ca')
+      expect(body).to eq(pem)
+    end
+
+    it 'returns the request response' do
+      stub_request(:get, url).to_return(body: pem)
+
+      resp, _ = subject.get_certificate('ca')
+      expect(resp).to be_a(Puppet::HTTP::Response)
     end
 
     it 'accepts text/plain responses' do
@@ -41,12 +101,29 @@ describe Puppet::HTTP::Service::Ca do
   context 'when getting CRLs' do
     let(:crl) { crl_fixture('crl.pem') }
     let(:pem) { crl.to_pem }
-    let(:url) { "https://www.example.com/certificate_revocation_list/ca" }
+    let(:url) { "https://www.example.com/puppet-ca/v1/certificate_revocation_list/ca" }
+
+    it 'includes headers set via the :http_extra_headers and :profile settings' do
+      stub_request(:get, url).with(headers: {'Example-Header' => 'real-thing', 'another' => 'thing', 'X-Puppet-Profiling' => 'true'})
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      subject.get_certificate_revocation_list
+    end
 
     it 'gets a CRL from "certificate_revocation_list" endpoint' do
       stub_request(:get, url).to_return(body: pem)
 
-      expect(subject.get_certificate_revocation_list).to eq(pem)
+      _, body = subject.get_certificate_revocation_list
+      expect(body).to eq(pem)
+    end
+
+    it 'returns the request response' do
+      stub_request(:get, url).to_return(body: pem)
+
+      resp, _ = subject.get_certificate_revocation_list
+      expect(resp).to be_a(Puppet::HTTP::Response)
     end
 
     it 'accepts text/plain responses' do
@@ -83,7 +160,16 @@ describe Puppet::HTTP::Service::Ca do
   context 'when submitting a CSR' do
     let(:request) { request_fixture('request.pem') }
     let(:pem) { request.to_pem }
-    let(:url) { "https://www.example.com/certificate_request/infinity" }
+    let(:url) { "https://www.example.com/puppet-ca/v1/certificate_request/infinity" }
+
+    it 'includes headers set via the :http_extra_headers and :profile settings' do
+      stub_request(:put, url).with(headers: {'Example-Header' => 'real-thing', 'another' => 'thing', 'X-Puppet-Profiling' => 'true'})
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      subject.put_certificate_request('infinity', request)
+    end
 
     it 'submits a CSR to the "certificate_request" endpoint' do
       stub_request(:put, url).with(body: pem, headers: { 'Content-Type' => 'text/plain' })
@@ -91,6 +177,13 @@ describe Puppet::HTTP::Service::Ca do
       subject.put_certificate_request('infinity', request)
     end
 
+    it 'returns the request response' do
+      stub_request(:put, url).with(body: pem, headers: { 'Content-Type' => 'text/plain' })
+
+      resp = subject.put_certificate_request('infinity', request)
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    end
+
     it 'raises response error if unsuccessful' do
       stub_request(:put, url).to_return(status: [400, 'Bad Request'])