puppet 6.16.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/{util/http_proxy_spec.rb → http/proxy_spec.rb}

@@ -1,10 +1,8 @@
 require 'uri'
 require 'spec_helper'
-require 'puppet/util/http_proxy'
-
-describe Puppet::Util::HttpProxy do
-  include Puppet::Network::HTTP::Compression.module
+require 'puppet/http'
 
+describe Puppet::HTTP::Proxy do
   before(:all) do
     ENV['http_proxy'] = nil
     ENV['HTTP_PROXY'] = nil
@@ -346,69 +344,4 @@ describe Puppet::Util::HttpProxy do
       end
     end
   end
-
-  describe '.request_with_redirects' do
-    let(:dest) { URI.parse('http://mydomain.com/some/path') }
-
-    it 'generates accept and accept-encoding headers' do
-      stub_request(:head, dest)
-
-      headers = {
-        'Accept' => '*/*',
-        'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-        'User-Agent' => /Puppet/
-      }
-      stub_request(:get, dest).with(headers: headers)
-
-      subject.request_with_redirects(dest, :get, 0)
-    end
-
-    it 'can return a compressed response body' do
-      stub_request(:head, dest)
-
-      compressed_body = [
-        0x1f, 0x8b, 0x08, 0x08, 0xe9, 0x08, 0x7a, 0x5a, 0x00, 0x03,
-        0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0xcb, 0xc8, 0xe4, 0x02,
-        0x00, 0x7a, 0x7a, 0x6f, 0xed, 0x03, 0x00, 0x00, 0x00
-      ].pack('C*')
-
-      stub_request(:get, dest).to_return(status: 200, body: compressed_body, headers: { 'Content-Encoding' => 'gzip' })
-
-      expect(
-        uncompress_body(subject.request_with_redirects(dest, :get, 0))
-      ).to eq("hi\n")
-    end
-
-    it 'generates accept and accept-encoding headers when a block is provided' do
-      stub_request(:head, dest)
-
-      headers = {
-        'Accept' => '*/*',
-        'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-        'User-Agent' => /Puppet/
-      }
-      stub_request(:get, dest).with(headers: headers)
-
-      subject.request_with_redirects(dest, :get, 0) do
-        # unused
-      end
-    end
-
-    it 'only makes a single HEAD request' do
-      stub_request(:head, dest)
-
-      subject.request_with_redirects(dest, :head, 0)
-    end
-
-    it 'preserves query parameters' do
-      url = URI.parse('http://mydomain.com/some/path?foo=bar')
-
-      stub_request(:head, url)
-      stub_request(:get, url)
-
-      subject.request_with_redirects(url, :get, 0) do
-        # unused
-      end
-    end
-  end
 end

data/spec/unit/http/resolver_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 
 describe Puppet::HTTP::Resolver do
@@ -29,7 +28,7 @@ describe Puppet::HTTP::Resolver do
     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)
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 200)
 
       service = subject.resolve(session, :ca)
       expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
@@ -37,34 +36,54 @@ describe Puppet::HTTP::Resolver do
     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)
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").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"
+    it 'includes extra http headers' do
+      Puppet[:http_extra_headers] = 'region:us-west'
 
-      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)
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server")
+        .with(headers: {'Region' => 'us-west'})
+
+      subject.resolve(session, :ca)
+    end
+
+    it 'uses the provided ssl context during resolution' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 200)
+
+      other_ctx = Puppet::SSL::SSLContext.new
+      expect(client).to receive(:connect).with(URI("https://ca.example.com:8141/status/v1/simple/server"), options: {ssl_context: other_ctx}).and_call_original
+
+      subject.resolve(session, :ca, ssl_context: other_ctx)
+    end
+
+    it 'logs unsuccessful HTTP 500 responses' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: [500, 'Internal Server Error'])
+      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/server").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)
+    it 'cancels resolution if no servers in server_list are accessible' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 503)
+      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/server").to_return(status: 503)
+
+      canceled = false
+      canceled_handler = lambda { |cancel| canceled = cancel }
 
-      expect { subject.resolve(session, :ca) }.to raise_error(Puppet::Error, /^Could not select a functional puppet master from server_list:/)
+      expect(subject.resolve(session, :ca, canceled_handler: canceled_handler)).to eq(nil)
+      expect(canceled).to eq(true)
     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)
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 503)
+      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/server").to_return(status: 200)
 
       service = subject.resolve(session, :ca)
       expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
@@ -72,8 +91,8 @@ describe Puppet::HTTP::Resolver do
     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)
+      failed = stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 503)
+      passed = stub_request(:get, "https://apple.example.com:8142/status/v1/simple/server").to_return(status: 200)
 
       service = subject.resolve(session, :puppet)
       expect(service).to be_a(Puppet::HTTP::Service::Compiler)

data/spec/unit/http/response_spec.rb

@@ -66,4 +66,10 @@ describe Puppet::HTTP::Response do
 
     expect(client.get(uri)['Content-Encoding']).to eq('gzip')
   end
+
+  it "enumerates headers" do
+    stub_request(:get, uri).to_return(status: 200, headers: { 'Content-Encoding' => 'gzip' })
+
+    expect(client.get(uri).each_header.to_a).to eq([['content-encoding', 'gzip']])
+  end
 end

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 
 describe Puppet::HTTP::Service::Ca do
@@ -39,11 +38,11 @@ describe Puppet::HTTP::Service::Ca do
       subject.get_certificate('ca')
     end
 
-    it 'fallbacks to server and masterport' do
+    it 'fallbacks to server and serverport' do
       Puppet[:ca_server] = nil
       Puppet[:ca_port] = nil
       Puppet[:server] = 'ca2.example.com'
-      Puppet[:masterport] = 8142
+      Puppet[:serverport] = 8142
 
       stub_request(:get, "https://ca2.example.com:8142/puppet-ca/v1/certificate/ca").to_return(body: pem)
 

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

@@ -1,6 +1,5 @@
 # coding: utf-8
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 
 describe Puppet::HTTP::Service::Compiler do
@@ -12,12 +11,11 @@ describe Puppet::HTTP::Service::Compiler do
   let(:node) { Puppet::Node.new(certname) }
   let(:facts) { Puppet::Node::Facts.new(certname) }
   let(:catalog) { Puppet::Resource::Catalog.new(certname) }
-  let(:status) { Puppet::Status.new }
   let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
 
   before :each do
     Puppet[:server] = 'compiler.example.com'
-    Puppet[:masterport] = 8140
+    Puppet[:serverport] = 8140
 
     Puppet::Node::Facts.indirection.terminus_class = :memory
   end
@@ -38,7 +36,7 @@ describe Puppet::HTTP::Service::Compiler do
   context 'when routing to the compiler service' do
     it 'defaults the server and port based on settings' do
       Puppet[:server] = 'compiler2.example.com'
-      Puppet[:masterport] = 8141
+      Puppet[:serverport] = 8141
 
       stub_request(:post, "https://compiler2.example.com:8141/puppet/v3/catalog/ziggy?environment=testing")
         .to_return(body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime })
@@ -132,6 +130,26 @@ describe Puppet::HTTP::Service::Compiler do
       subject.post_catalog(certname, environment: 'production', facts: facts, checksum_type: %w[sha256 sha384])
     end
 
+    it 'does not accept msgpack by default' do
+      stub_request(:post, uri)
+        .with(headers: {'Accept' => 'application/vnd.puppet.rich+json, application/json, text/pson'})
+        .to_return(**catalog_response)
+
+      allow(Puppet.features).to receive(:msgpack?).and_return(false)
+
+      subject.post_catalog(certname, environment: environment, facts: facts)
+    end
+
+    it 'accepts msgpack & rich_json_msgpack if the gem is present' do
+      stub_request(:post, uri)
+        .with(headers: {'Accept' => 'application/vnd.puppet.rich+json, application/json, application/vnd.puppet.rich+msgpack, application/x-msgpack, text/pson'})
+        .to_return(**catalog_response)
+
+      allow(Puppet.features).to receive(:msgpack?).and_return(true)
+
+      subject.post_catalog(certname, environment: environment, facts: facts)
+    end
+
     it 'returns a deserialized catalog' do
       stub_request(:post, uri)
         .to_return(**catalog_response)
@@ -141,6 +159,35 @@ describe Puppet::HTTP::Service::Compiler do
       expect(cat.name).to eq(certname)
     end
 
+    it 'deserializes the catalog from msgpack', if: Puppet.features.msgpack? do
+      body = catalog.to_msgpack
+      formatter = Puppet::Network::FormatHandler.format(:msgpack)
+      catalog_response = { body: body, headers: {'Content-Type' => formatter.mime }}
+
+      stub_request(:post, uri)
+        .to_return(**catalog_response)
+
+      _, cat = subject.post_catalog(certname, environment: 'production', facts: facts)
+      expect(cat).to be_a(Puppet::Resource::Catalog)
+      expect(cat.name).to eq(certname)
+    end
+
+    it 'deserializes the catalog from rich msgpack', if: Puppet.features.msgpack? do
+      body = Puppet.override(rich_data: true) do
+        catalog.to_msgpack
+      end
+
+      formatter = Puppet::Network::FormatHandler.format(:rich_data_msgpack)
+      catalog_response = { body: body, headers: {'Content-Type' => formatter.mime }}
+
+      stub_request(:post, uri)
+        .to_return(**catalog_response)
+
+      _, cat = subject.post_catalog(certname, environment: 'production', facts: facts)
+      expect(cat).to be_a(Puppet::Resource::Catalog)
+      expect(cat.name).to eq(certname)
+    end
+
     it 'returns the request response' do
       stub_request(:post, uri)
         .to_return(**catalog_response)
@@ -418,67 +465,6 @@ describe Puppet::HTTP::Service::Compiler do
     end
   end
 
-  context 'when getting status' do
-    let(:uri) { %r{/puppet/v3/status/ziggy} }
-    let(:status_response) { { body: formatter.render(status), headers: {'Content-Type' => formatter.mime } } }
-
-    it 'always sends production' do
-      stub_request(:get, uri)
-          .with(query: hash_including("environment" => "production"))
-          .to_return(**status_response)
-
-      subject.get_status(certname)
-    end
-
-    it 'returns a deserialized status' do
-      stub_request(:get, uri)
-        .to_return(**status_response)
-
-      _, s = subject.get_status(certname)
-      expect(s).to be_a(Puppet::Status)
-      expect(s.status).to eq("is_alive" => true)
-    end
-
-    it 'returns the request response' do
-      stub_request(:get, uri)
-        .to_return(**status_response)
-
-      resp, _ = subject.get_status(certname)
-      expect(resp).to be_a(Puppet::HTTP::Response)
-    end
-
-    it 'raises a response error if unsuccessful' do
-      stub_request(:get, uri)
-        .to_return(status: [500, "Server Error"])
-
-      expect {
-        subject.get_status(certname)
-      }.to raise_error do |err|
-        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
-        expect(err.message).to eq('Server Error')
-        expect(err.response.code).to eq(500)
-      end
-    end
-
-    it 'raises a protocol error if the content-type header is missing' do
-      stub_request(:get, uri)
-        .to_return(body: "content-type is missing")
-
-      expect {
-        subject.get_status(certname)
-      }.to raise_error(Puppet::HTTP::ProtocolError, /No content type in http response; cannot parse/)
-    end
-
-    it 'raises a serialization error if the content is invalid' do
-      stub_request(:get, uri)
-        .to_return(body: "this isn't valid JSON", headers: {'Content-Type' => 'application/json'})
-
-      expect {
-        subject.get_status(certname)
-      }.to raise_error(Puppet::HTTP::SerializationError, /Failed to deserialize Puppet::Status from json/)
-    end
-  end
-
   context 'filebucket' do
     let(:filebucket_file) { Puppet::FileBucket::File.new('file to store') }
     let(:formatter) { Puppet::Network::FormatHandler.format(:binary) }

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 
 describe Puppet::HTTP::Service::FileServer do
@@ -13,7 +12,7 @@ describe Puppet::HTTP::Service::FileServer do
 
   before :each do
     Puppet[:server] = 'www.example.com'
-    Puppet[:masterport] = 443
+    Puppet[:serverport] = 443
   end
 
   context 'when making requests' do
@@ -32,7 +31,7 @@ describe Puppet::HTTP::Service::FileServer do
   context 'when routing to the file service' do
     it 'defaults the server and port based on settings' do
       Puppet[:server] = 'file.example.com'
-      Puppet[:masterport] = 8141
+      Puppet[:serverport] = 8141
 
       stub_request(:get, "https://file.example.com:8141/puppet/v3/file_content/:mount/:path?environment=testing")
 
@@ -42,7 +41,7 @@ describe Puppet::HTTP::Service::FileServer do
 
   context 'retrieving file metadata' do
     let(:path) { tmpfile('get_file_metadata') }
-    let(:url) { "https://www.example.com/puppet/v3/file_metadata/:mount/#{path}?checksum_type=md5&environment=testing&links=manage&source_permissions=ignore" }
+    let(:url) { "https://www.example.com/puppet/v3/file_metadata/:mount/#{path}?checksum_type=sha256&environment=testing&links=manage&source_permissions=ignore" }
     let(:filemetadata) { Puppet::FileServing::Metadata.new(path) }
     let(:request_path) { "/:mount/#{path}"}
 
@@ -123,7 +122,7 @@ describe Puppet::HTTP::Service::FileServer do
 
   context 'retrieving multiple file metadatas' do
     let(:path) { tmpfile('get_file_metadatas') }
-    let(:url) { "https://www.example.com/puppet/v3/file_metadatas/:mount/#{path}?checksum_type=md5&links=manage&recurse=false&source_permissions=ignore&environment=testing" }
+    let(:url) { "https://www.example.com/puppet/v3/file_metadatas/:mount/#{path}?checksum_type=sha256&links=manage&recurse=false&source_permissions=ignore&environment=testing" }
     let(:filemetadatas) { [Puppet::FileServing::Metadata.new(path)] }
     let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
     let(:request_path) { "/:mount/#{path}"}
@@ -159,7 +158,7 @@ describe Puppet::HTTP::Service::FileServer do
     end
 
     it 'automatically converts an array of parameters to the stringified query' do
-      url = "https://www.example.com/puppet/v3/file_metadatas/:mount/#{path}?checksum_type=md5&environment=testing&ignore=CVS&ignore=.git&ignore=.hg&links=manage&recurse=false&source_permissions=ignore"
+      url = "https://www.example.com/puppet/v3/file_metadatas/:mount/#{path}?checksum_type=sha256&environment=testing&ignore=CVS&ignore=.git&ignore=.hg&links=manage&recurse=false&source_permissions=ignore"
       stub_request(:get, url).with(
         headers: {'Accept'=>'application/json, application/x-msgpack, text/pson',}
       ).to_return(

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

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'puppet/http'
+
+describe Puppet::HTTP::Service::Puppetserver do
+  let(:ssl_context) { Puppet::SSL::SSLContext.new }
+  let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
+  let(:subject) { client.create_session.route_to(:puppetserver) }
+
+  before :each do
+    Puppet[:server] = 'puppetserver.example.com'
+  end
+
+  context 'when making requests' do
+    it 'includes default HTTP headers' do
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/server").with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        expect(request.headers).to_not include('X-Puppet-Profiling')
+      end.to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+
+    it 'includes extra headers' do
+      Puppet[:http_extra_headers] = 'region:us-west'
+
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/server")
+        .with(headers: {'Region' => 'us-west'})
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+  end
+
+  context 'when routing to the puppetserver service' do
+    it 'defaults the server and port based on settings' do
+      Puppet[:server] = 'compiler2.example.com'
+      Puppet[:serverport] = 8141
+
+      stub_request(:get, "https://compiler2.example.com:8141/status/v1/simple/server")
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+  end
+
+  context 'when getting puppetserver status' do
+    let(:url) { "https://puppetserver.example.com:8140/status/v1/simple/server" }
+
+    it 'returns the request response and status' do
+      stub_request(:get, url)
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      resp, status = subject.get_simple_status
+      expect(resp).to be_a(Puppet::HTTP::Response)
+      expect(status).to eq('running')
+    end
+
+    it 'raises a response error if unsuccessful' do
+      stub_request(:get, url).to_return(status: [500, 'Internal Server Error'])
+
+      expect {
+        subject.get_simple_status
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
+        expect(err.message).to eq("Internal Server Error")
+        expect(err.response.code).to eq(500)
+      end
+    end
+
+    it 'accepts an ssl context' do
+      stub_request(:get, url)
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      other_ctx = Puppet::SSL::SSLContext.new
+      expect(client).to receive(:connect).with(URI(url), options: {ssl_context: other_ctx}).and_call_original
+
+      session = client.create_session
+      service = Puppet::HTTP::Service.create_service(client, session, :puppetserver, 'puppetserver.example.com', 8140)
+      service.get_simple_status(ssl_context: other_ctx)
+    end
+  end
+
+  context 'when /status/v1/simple/server returns not found' do
+    it 'calls /status/v1/simple/master' do
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/server")
+        .to_return(status: [404, 'not found: server'])
+
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master")
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      resp, status = subject.get_simple_status
+      expect(resp).to be_a(Puppet::HTTP::Response)
+      expect(status).to eq('running')
+    end
+
+    it 'raises a response error if fallback is unsuccessful' do
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/server")
+        .to_return(status: [404, 'not found: server'])
+
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master")
+        .to_return(status: [404, 'not found: master'])
+
+      expect {
+        subject.get_simple_status
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
+        expect(err.message).to eq('not found: master')
+        expect(err.response.code).to eq(404)
+      end
+    end
+  end
+end