puppet 6.13.0-x86-mingw32 → 6.14.0-x86-mingw32

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

@@ -27,14 +27,6 @@ describe Puppet::HTTP::Service::FileServer do
 
       subject.get_file_content(path: '/:mount/:path', environment: environment) { |data| }
     end
-
-    it 'includes the X-Puppet-Profiling header when Puppet[:profile] is true' do
-      stub_request(:get, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./, 'X-Puppet-Profiling' => 'true'})
-
-      Puppet[:profile] = true
-
-      subject.get_file_content(path: '/:mount/:path', environment: environment) { |data| }
-    end
   end
 
   context 'when routing to the file service' do
@@ -54,6 +46,16 @@ describe Puppet::HTTP::Service::FileServer do
     let(:filemetadata) { Puppet::FileServing::Metadata.new(path) }
     let(:request_path) { "/:mount/#{path}"}
 
+    it 'includes puppet 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'}).
+        to_return(status: 200, body: filemetadata.render, headers: { 'Content-Type' => 'application/json' })
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      subject.get_file_metadata(path: request_path, environment: environment)
+    end
+
     it 'submits a request for file metadata to the server' do
       stub_request(:get, url).with(
         headers: {'Accept'=>'application/json, application/x-msgpack, text/pson',}
@@ -117,6 +119,16 @@ describe Puppet::HTTP::Service::FileServer do
     let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
     let(:request_path) { "/:mount/#{path}"}
 
+    it 'includes puppet 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'}).
+        to_return(status: 200, body: formatter.render_multiple(filemetadatas), headers: { 'Content-Type' => 'application/json' })
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      subject.get_file_metadatas(path: request_path, environment: environment)
+    end
+
     it 'submits a request for file metadata to the server' do
       stub_request(:get, url).with(
         headers: {'Accept'=>'application/json, application/x-msgpack, text/pson',}
@@ -188,6 +200,18 @@ describe Puppet::HTTP::Service::FileServer do
   context 'getting file content' do
     let(:uri) {"https://www.example.com:443/puppet/v3/file_content/:mount/:path?environment=testing"}
 
+    it 'includes puppet headers set via the :http_extra_headers and :profile settings' do
+      stub_request(:get, uri).with(headers: {'Example-Header' => 'real-thing', 'another' => 'thing', 'X-Puppet-Profiling' => 'true'}).
+        to_return(status: 200, body: "and beyond")
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      expect { |b|
+        subject.get_file_content(path: '/:mount/:path', environment: environment, &b)
+      }.to yield_with_args("and beyond")
+    end
+
     it 'yields file content' do
       stub_request(:get, uri).with do |request|
         expect(request.headers).to include({'Accept' => 'application/octet-stream'})
@@ -216,4 +240,37 @@ describe Puppet::HTTP::Service::FileServer do
       }.to raise_error(ArgumentError, 'Path must start with a slash')
     end
   end
+
+  context 'getting static file content' do
+    let(:code_id) { "0fc72115-adc6-4b1a-aa50-8f31b3ece440" }
+    let(:uri) { "https://www.example.com:443/puppet/v3/static_file_content/:mount/:path?environment=testing&code_id=#{code_id}"}
+
+    it 'yields file content' do
+      stub_request(:get, uri).with do |request|
+        expect(request.headers).to include({'Accept' => 'application/octet-stream'})
+      end.to_return(status: 200, body: "and beyond")
+
+      expect { |b|
+        subject.get_static_file_content(path: '/:mount/:path', environment: environment, code_id: code_id, &b)
+      }.to yield_with_args("and beyond")
+    end
+
+    it 'raises response error if unsuccessful' do
+      stub_request(:get, uri).to_return(status: [400, 'Bad Request'])
+
+      expect {
+        subject.get_static_file_content(path: '/:mount/:path', environment: environment, code_id: code_id) { |data| }
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
+        expect(err.message).to eq('Bad Request')
+        expect(err.response.code).to eq(400)
+      end
+    end
+
+    it 'raises response error if path is relative' do
+      expect {
+        subject.get_static_file_content(path: 'relative_path', environment: environment, code_id: code_id) { |data| }
+      }.to raise_error(ArgumentError, 'Path must start with a slash')
+    end
+  end
 end

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

@@ -25,14 +25,6 @@ describe Puppet::HTTP::Service::Report do
 
       subject.put_report('report', report, environment: environment)
     end
-
-    it 'includes the X-Puppet-Profiling header when Puppet[:profile] is true' do
-      stub_request(:put, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./, 'X-Puppet-Profiling' => 'true'})
-
-      Puppet[:profile] = true
-
-      subject.put_report('report', report, environment: environment)
-    end
   end
 
   context 'when routing to the report service' do
@@ -60,6 +52,15 @@ describe Puppet::HTTP::Service::Report do
   context 'when submitting a report' do
     let(:url) { "https://www.example.com/puppet/v3/report/infinity?environment=testing" }
 
+    it 'includes puppet 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_report('infinity', report, environment: environment)
+    end
+
     it 'submits a report to the "report" endpoint' do
       stub_request(:put, url)
         .with(
@@ -79,6 +80,14 @@ describe Puppet::HTTP::Service::Report do
       subject.put_report('node name', report, environment: environment)
     end
 
+    it 'returns the response whose body contains the list of report processors' do
+      body = "[\"store\":\"http\"]"
+      stub_request(:put, url)
+        .to_return(status: 200, body: body, headers: {'Content-Type' => 'application/json'})
+
+      expect(subject.put_report('infinity', report, environment: environment).body).to eq(body)
+    end
+
     it 'raises response error if unsuccessful' do
       stub_request(:put, url).to_return(status: [400, 'Bad Request'], headers: {'X-Puppet-Version' => '6.1.8' })
 

data/spec/unit/http/service_spec.rb

@@ -1,19 +1,79 @@
 require 'spec_helper'
 require 'webmock/rspec'
 require 'puppet/http'
+require 'puppet/file_serving'
+require 'puppet/file_serving/content'
+require 'puppet/file_serving/metadata'
 
 describe Puppet::HTTP::Service do
   let(:ssl_context) { Puppet::SSL::SSLContext.new }
   let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
+  let(:session) { Puppet::HTTP::Session.new(client, []) }
   let(:url) { URI.parse('https://www.example.com') }
-  let(:service) { described_class.new(client, url) }
+  let(:service) { described_class.new(client, session, url) }
+
+  class TestService < Puppet::HTTP::Service
+    def get_test(ssl_context)
+       @client.get(
+        url,
+        headers: add_puppet_headers({'Default-Header' => 'default-value'}),
+        ssl_context: ssl_context
+      )
+    end
+
+    def mime_types(model)
+      get_mime_types(model)
+    end
+  end
+
+  context 'when modifying headers for an http request' do
+    let(:service) { TestService.new(client, session, url) }
+
+    it 'adds custom user-specified headers' do
+      stub_request(:get, "https://www.example.com/").
+         with( headers: { 'Default-Header'=>'default-value', 'Header2'=>'newvalue' })
+
+      Puppet[:http_extra_headers] = 'header2:newvalue'
+
+      service.get_test(ssl_context)
+    end
+
+    it 'adds X-Puppet-Profiling header if set' do
+      stub_request(:get, "https://www.example.com/").
+         with( headers: { 'Default-Header'=>'default-value', 'X-Puppet-Profiling'=>'true' })
+
+      Puppet[:profile] = true
+
+      service.get_test(ssl_context)
+    end
+
+    it 'ignores a custom header does not have a value' do
+      stub_request(:get, "https://www.example.com/").with do |request|
+        expect(request.headers).to include({'Default-Header' => 'default-value'})
+        expect(request.headers).to_not include('header-with-no-value')
+      end
+
+      Puppet[:http_extra_headers] = 'header-with-no-value:'
+
+      service.get_test(ssl_context)
+    end
+
+    it 'ignores a custom header that already exists (case insensitive) in the header hash' do
+      stub_request(:get, "https://www.example.com/").
+         with( headers: { 'Default-Header'=>'default-value' })
+
+      Puppet[:http_extra_headers] = 'default-header:wrongvalue'
+
+      service.get_test(ssl_context)
+    end
+  end
 
   it "returns a URI containing the base URL and path" do
     expect(service.with_base_url('/puppet/v3')).to eq(URI.parse("https://www.example.com/puppet/v3"))
   end
 
   it "doesn't modify frozen the base URL" do
-    service = described_class.new(client, url.freeze)
+    service = described_class.new(client, session, url.freeze)
     service.with_base_url('/puppet/v3')
   end
 
@@ -36,7 +96,7 @@ describe Puppet::HTTP::Service do
 
   it 'raises for unknown service names' do
     expect {
-      described_class.create_service(client, :westbound)
+      described_class.create_service(client, session, :westbound)
     }.to raise_error(ArgumentError, "Unknown service westbound")
   end
 
@@ -53,4 +113,33 @@ describe Puppet::HTTP::Service do
   it "returns false for unknown service names" do
     expect(described_class.valid_name?(:westbound)).to eq(false)
   end
+
+  it 'returns different mime types for different models' do
+    mimes = if Puppet.features.msgpack?
+              %w[application/json application/x-msgpack text/pson]
+            else
+              %w[application/json text/pson]
+            end
+
+    service = TestService.new(client, session, url)
+    [
+      Puppet::Node,
+      Puppet::Node::Facts,
+      Puppet::Transaction::Report,
+      Puppet::FileServing::Metadata,
+      Puppet::Status
+    ].each do |model|
+      expect(service.mime_types(model)).to eq(mimes)
+    end
+
+    # These are special
+    expect(service.mime_types(Puppet::FileServing::Content)).to eq(%w[application/octet-stream])
+
+    catalog_mimes = if Puppet.features.msgpack?
+                      %w[application/vnd.puppet.rich+json application/json application/vnd.puppet.rich+msgpack application/x-msgpack text/pson]
+                    else
+                      %w[application/vnd.puppet.rich+json application/json application/vnd.puppet.rich+msgpack text/pson]
+                    end
+    expect(service.mime_types(Puppet::Resource::Catalog)).to eq(catalog_mimes)
+  end
 end

data/spec/unit/http/session_spec.rb

@@ -155,7 +155,6 @@ describe Puppet::HTTP::Session do
       }.to raise_error(Puppet::Error, "Could not select a functional puppet master from server_list: 'foo.example.com,bar.example.com'")
     end
 
-
     it "raises when there are no more routes" do
       allow_any_instance_of(Net::HTTP).to receive(:start).and_raise(Errno::EHOSTUNREACH)
       session = client.create_session
@@ -164,5 +163,109 @@ describe Puppet::HTTP::Session do
         session.route_to(:ca)
       }.to raise_error(Puppet::HTTP::RouteError, 'No more routes to ca')
     end
+
+    Puppet::HTTP::Service::SERVICE_NAMES.each do |name|
+      it "resolves #{name} using server_list" do
+        stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 200)
+
+        session.route_to(name)
+      end
+    end
+
+    it 'does not use server_list to resolve the ca service when ca_server is explicitly set' do
+      Puppet[:ca_server] = 'banana.example.com'
+
+      expect(session.route_to(:ca).url.to_s).to eq("https://banana.example.com:8140/puppet-ca/v1")
+    end
+
+    it 'does not use server_list to resolve the report service when the report_server is explicitly set' do
+      Puppet[:report_server] = 'cherry.example.com'
+
+      expect(session.route_to(:report).url.to_s).to eq("https://cherry.example.com:8140/puppet/v3")
+    end
+  end
+
+  context 'when retrieving capabilities' do
+    let(:session) do
+      resolver = DummyResolver.new(good_service)
+      described_class.new(client, [resolver])
+    end
+
+    it 'raises for unknown service names' do
+      expect {
+        session = described_class.new(client, [])
+        session.supports?(:westbound, 'a capability')
+      }.to raise_error(ArgumentError, "Unknown service westbound")
+    end
+
+    context 'locales' do
+      it 'does not support locales if the cached service has not been resolved' do
+        session = described_class.new(client, [])
+
+        expect(session).to_not be_supports(:puppet, 'locales')
+      end
+
+      it "supports locales if the cached service's version is 5.3.4 or greater" do
+        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.3.4'}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to be_supports(:puppet, 'locales')
+      end
+
+      it "does not support locales if the cached service's version is 5.3.3" do
+        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.3.3'}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to_not be_supports(:puppet, 'locales')
+      end
+
+      it "does not support locales if the cached service's version is missing" do
+        response = Puppet::HTTP::Response.new({}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to_not be_supports(:puppet, 'locales')
+      end
+    end
+
+    context 'json' do
+      it 'does not support json if the cached service has not been resolved' do
+        session = described_class.new(client, [])
+
+        expect(session).to_not be_supports(:puppet, 'json')
+      end
+
+      it "supports json if the cached service's version is 5 or greater" do
+        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.5.12'}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to be_supports(:puppet, 'json')
+      end
+
+      it "does not support json if the cached service's version is less than 5.0" do
+        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '4.10.1'}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to_not be_supports(:puppet, 'json')
+      end
+
+      it "supports json if the cached service's version is missing" do
+        response = Puppet::HTTP::Response.new({}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to be_supports(:puppet, 'json')
+      end
+    end
   end
 end

data/spec/unit/indirector/catalog/rest_spec.rb

@@ -3,7 +3,64 @@ require 'spec_helper'
 require 'puppet/indirector/catalog/rest'
 
 describe Puppet::Resource::Catalog::Rest do
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    expect(Puppet::Resource::Catalog::Rest.superclass).to equal(Puppet::Indirector::REST)
+  let(:certname) { 'ziggy' }
+  let(:uri) { %r{/puppet/v3/catalog/ziggy} }
+  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+  let(:catalog) { Puppet::Resource::Catalog.new(certname) }
+
+  before :each do
+    Puppet[:server] = 'compiler.example.com'
+    Puppet[:masterport] = 8140
+
+    described_class.indirection.terminus_class = :rest
+  end
+
+  def catalog_response(catalog)
+    { body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime } }
+  end
+
+  it 'finds a catalog' do
+    stub_request(:post, uri).to_return(**catalog_response(catalog))
+
+    expect(described_class.indirection.find(certname)).to be_a(Puppet::Resource::Catalog)
+  end
+
+  it "serializes the environment" do
+    stub_request(:post, uri)
+      .with(query: hash_including('environment' => 'outerspace'))
+      .to_return(**catalog_response(catalog))
+
+    described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
+  end
+
+  it 'constructs a catalog environment_instance' do
+    env = Puppet::Node::Environment.remote('outerspace')
+    catalog = Puppet::Resource::Catalog.new(certname, env)
+
+    stub_request(:post, uri).to_return(**catalog_response(catalog))
+
+    expect(described_class.indirection.find(certname).environment_instance).to eq(env)
+  end
+
+  it 'returns nil if the node does not exist' do
+    stub_request(:post, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
+
+    expect(described_class.indirection.find(certname)).to be_nil
+  end
+
+  it 'raises if fail_on_404 is specified' do
+    stub_request(:post, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
+
+    expect{
+      described_class.indirection.find(certname, fail_on_404: true)
+    }.to raise_error(Puppet::Error, %r{Find /puppet/v3/catalog/ziggy resulted in 404 with the message: {}})
+  end
+
+  it 'raises Net::HTTPError on 500' do
+    stub_request(:post, uri).to_return(status: 500)
+
+    expect{
+      described_class.indirection.find(certname)
+    }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
   end
 end