puppet 6.13.0-x86-mingw32 → 6.18.0-x86-mingw32

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
@@ -27,14 +26,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 +45,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',}
@@ -61,10 +62,19 @@ describe Puppet::HTTP::Service::FileServer do
         status: 200, body: filemetadata.render, headers: { 'Content-Type' => 'application/json' }
       )
 
-      metadata = subject.get_file_metadata(path: request_path, environment: environment)
+      _, metadata = subject.get_file_metadata(path: request_path, environment: environment)
       expect(metadata.path).to eq(path)
     end
 
+    it 'returns the request response' do
+      stub_request(:get, url).to_return(
+        status: 200, body: filemetadata.render, headers: { 'Content-Type' => 'application/json' }
+      )
+
+      resp, _ = subject.get_file_metadata(path: request_path, environment: environment)
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    end
+
     it 'raises a protocol error if the Content-Type header is missing from the response' do
       stub_request(:get, url).to_return(status: 200, body: '', headers: {})
 
@@ -117,6 +127,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',}
@@ -124,10 +144,19 @@ describe Puppet::HTTP::Service::FileServer do
         status: 200, body: formatter.render_multiple(filemetadatas), headers: { 'Content-Type' => 'application/json' }
       )
 
-      metadatas = subject.get_file_metadatas(path: request_path, environment: environment)
+      _, metadatas = subject.get_file_metadatas(path: request_path, environment: environment)
       expect(metadatas.first.path).to eq(path)
     end
 
+    it 'returns the request response' do
+      stub_request(:get, url).to_return(
+        status: 200, body: formatter.render_multiple(filemetadatas), headers: { 'Content-Type' => 'application/json' }
+      )
+
+      resp, _ = subject.get_file_metadatas(path: request_path, environment: environment)
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    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"
       stub_request(:get, url).with(
@@ -136,7 +165,7 @@ describe Puppet::HTTP::Service::FileServer do
         status: 200, body: formatter.render_multiple(filemetadatas), headers: { 'Content-Type' => 'application/json' }
       )
 
-      metadatas = subject.get_file_metadatas(path: request_path, environment: environment, ignore: ['CVS', '.git', '.hg'])
+      _, metadatas = subject.get_file_metadatas(path: request_path, environment: environment, ignore: ['CVS', '.git', '.hg'])
       expect(metadatas.first.path).to eq(path)
     end
 
@@ -188,6 +217,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'})
@@ -198,6 +239,13 @@ describe Puppet::HTTP::Service::FileServer do
       }.to yield_with_args("and beyond")
     end
 
+    it 'returns the request response' do
+      stub_request(:get, uri)
+
+      resp = subject.get_file_content(path: '/:mount/:path', environment: environment) { |b| b }
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    end
+
     it 'raises response error if unsuccessful' do
       stub_request(:get, uri).to_return(status: [400, 'Bad Request'])
 
@@ -216,4 +264,44 @@ 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 'returns the request response' do
+      stub_request(:get, uri)
+
+      resp = subject.get_static_file_content(path: '/:mount/:path', environment: environment, code_id: code_id) { |b| b }
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 
 describe Puppet::HTTP::Service::Report do
@@ -25,14 +24,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 +51,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 +79,16 @@ 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'})
+
+      resp = subject.put_report('infinity', report, environment: environment)
+      expect(resp.body).to eq(body)
+      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'], headers: {'X-Puppet-Version' => '6.1.8' })
 

data/spec/unit/http/service_spec.rb

@@ -1,19 +1,78 @@
 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'}),
+        options: {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
 
@@ -22,21 +81,21 @@ describe Puppet::HTTP::Service do
   end
 
   it "connects to the base URL with a nil ssl context" do
-    expect(client).to receive(:connect).with(url, ssl_context: nil)
+    expect(client).to receive(:connect).with(url, options: {ssl_context: nil})
 
     service.connect
   end
 
   it "accepts an optional ssl_context" do
     other_ctx = Puppet::SSL::SSLContext.new
-    expect(client).to receive(:connect).with(url, ssl_context: other_ctx)
+    expect(client).to receive(:connect).with(url, options: {ssl_context: other_ctx})
 
     service.connect(ssl_context: other_ctx)
   end
 
   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 +112,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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 
 describe Puppet::HTTP::Session do
@@ -10,10 +9,14 @@ describe Puppet::HTTP::Session do
     double('good', url: uri, connect: nil)
   }
   let(:bad_service) {
+    create_bad_service
+  }
+
+  def create_bad_service(failure_message = 'whoops')
     service = double('bad', url: uri)
-    allow(service).to receive(:connect).and_raise(Puppet::HTTP::ConnectionError, 'whoops')
+    allow(service).to receive(:connect).and_raise(Puppet::HTTP::ConnectionError, failure_message)
     service
-  }
+  end
 
   class DummyResolver < Puppet::HTTP::Resolver
     attr_reader :count
@@ -23,21 +26,19 @@ describe Puppet::HTTP::Session do
       @count = 0
     end
 
-    def resolve(session, name, ssl_context: nil)
+    def resolve(session, name, ssl_context: nil, error_handler: nil)
       @count += 1
-      return @service if check_connection?(session, @service, ssl_context: ssl_context)
+      return @service if check_connection?(session, @service, ssl_context: ssl_context, error_handler: error_handler)
     end
   end
 
   context 'when routing' do
     it 'returns the first resolved service' do
-      Puppet[:log_level] = :debug
       resolvers = [DummyResolver.new(bad_service), DummyResolver.new(good_service)]
       session = described_class.new(client, resolvers)
       resolved = session.route_to(:ca)
 
       expect(resolved).to eq(good_service)
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Connection to #{uri} failed, trying next route: whoops"))
     end
 
     it 'only resolves once per session' do
@@ -58,6 +59,29 @@ describe Puppet::HTTP::Session do
       }.to raise_error(Puppet::HTTP::RouteError, 'No more routes to ca')
     end
 
+    it 'logs all routing failures as errors when there are no more routes' do
+      resolvers = [DummyResolver.new(create_bad_service('whoops1')), DummyResolver.new(create_bad_service('whoops2'))]
+      session = described_class.new(client, resolvers)
+
+      expect {
+        session.route_to(:ca)
+      }.to raise_error(Puppet::HTTP::RouteError, 'No more routes to ca')
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: "whoops1"),
+                               an_object_having_attributes(level: :err, message: "whoops2"))
+    end
+
+    it 'logs routing failures as debug until routing succeeds' do
+      Puppet[:log_level] = 'debug'
+
+      resolvers = [DummyResolver.new(bad_service), DummyResolver.new(good_service)]
+      session = described_class.new(client, resolvers)
+      session.route_to(:ca)
+
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Connection to #{uri} failed, trying next route: whoops"))
+      expect(@logs).to_not include(an_object_having_attributes(level: :err))
+    end
+
     it 'accepts an ssl context to use when connecting' do
       alt_context = Puppet::SSL::SSLContext.new
       expect(good_service).to receive(:connect).with(ssl_context: alt_context)
@@ -155,7 +179,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 +187,133 @@ 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
+        Puppet[:server_list] = 'apple.example.com'
+        req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+
+        session.route_to(name)
+
+        expect(req).to have_been_requested
+      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
+
+    it 'resolves once for all services in a session' do
+      Puppet[:server_list] = 'apple.example.com'
+      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+
+      Puppet::HTTP::Service::SERVICE_NAMES.each do |name|
+        session.route_to(name)
+      end
+
+      expect(req).to have_been_requested
+    end
+
+    it 'resolves server_list for each new session' do
+      Puppet[:server_list] = 'apple.example.com'
+      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+
+      client.create_session.route_to(:puppet)
+      client.create_session.route_to(:puppet)
+
+      expect(req).to have_been_requested.twice
+    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