puppet 6.12.0 → 6.17.0

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

@@ -0,0 +1,308 @@
+require 'spec_helper'
+require 'webmock/rspec'
+require 'puppet/http'
+
+describe Puppet::HTTP::Service::FileServer do
+  include PuppetSpec::Files
+
+  let(:ssl_context) { Puppet::SSL::SSLContext.new }
+  let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
+  let(:subject) { client.create_session.route_to(:fileserver) }
+  let(:environment) { 'testing' }
+  let(:report) { Puppet::Transaction::Report.new }
+
+  before :each do
+    Puppet[:server] = 'www.example.com'
+    Puppet[:masterport] = 443
+  end
+
+  context 'when making requests' do
+    let(:uri) {"https://www.example.com:443/puppet/v3/file_content/:mount/:path?environment=testing"}
+
+    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_file_content(path: '/:mount/:path', environment: environment) { |data| }
+    end
+  end
+
+  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
+
+      stub_request(:get, "https://file.example.com:8141/puppet/v3/file_content/:mount/:path?environment=testing")
+
+      subject.get_file_content(path: '/:mount/:path', environment: environment) { |data| }
+    end
+  end
+
+  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(: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',}
+      ).to_return(
+        status: 200, body: filemetadata.render, headers: { 'Content-Type' => 'application/json' }
+      )
+
+      _, 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: {})
+
+      expect {
+        subject.get_file_metadata(path: request_path, environment: environment)
+      }.to raise_error(Puppet::HTTP::ProtocolError, "No content type in http response; cannot parse")
+    end
+
+    it 'raises an error if the Content-Type is unsupported' do
+      stub_request(:get, url).to_return(status: 200, body: '', headers: { 'Content-Type' => 'text/yaml' })
+
+      expect {
+        subject.get_file_metadata(path: request_path, environment: environment)
+      }.to raise_error(Puppet::HTTP::ProtocolError, "Content-Type is unsupported")
+    end
+
+    it 'raises response error if unsuccessful' do
+      stub_request(:get, url).to_return(status: [400, 'Bad Request'])
+
+      expect {
+        subject.get_file_metadata(path: request_path, environment: environment)
+      }.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 a serialization error if serialization fails' do
+      stub_request(:get, url).to_return(
+        status: 200, body: '', headers: { 'Content-Type' => 'application/json' }
+      )
+
+      expect {
+        subject.get_file_metadata(path: request_path, environment: environment)
+      }.to raise_error(Puppet::HTTP::SerializationError, /Failed to deserialize Puppet::FileServing::Metadata from json/)
+    end
+
+    it 'raises response error if path is relative' do
+      expect {
+        subject.get_file_metadata(path: 'relative_path', environment: environment)
+      }.to raise_error(ArgumentError, 'Path must start with a slash')
+    end
+  end
+
+  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(:filemetadatas) { [Puppet::FileServing::Metadata.new(path)] }
+    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',}
+      ).to_return(
+        status: 200, body: formatter.render_multiple(filemetadatas), headers: { 'Content-Type' => 'application/json' }
+      )
+
+      _, 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(
+        headers: {'Accept'=>'application/json, application/x-msgpack, text/pson',}
+      ).to_return(
+        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'])
+      expect(metadatas.first.path).to eq(path)
+    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: {})
+
+      expect {
+        subject.get_file_metadatas(path: request_path, environment: environment)
+      }.to raise_error(Puppet::HTTP::ProtocolError, "No content type in http response; cannot parse")
+    end
+
+    it 'raises an error if the Content-Type is unsupported' do
+      stub_request(:get, url).to_return(status: 200, body: '', headers: { 'Content-Type' => 'text/yaml' })
+
+      expect {
+        subject.get_file_metadatas(path: request_path, environment: environment)
+      }.to raise_error(Puppet::HTTP::ProtocolError, "Content-Type is unsupported")
+    end
+
+    it 'raises response error if unsuccessful' do
+      stub_request(:get, url).to_return(status: [400, 'Bad Request'])
+
+      expect {
+        subject.get_file_metadatas(path: request_path, environment: environment)
+      }.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 a serialization error if serialization fails' do
+      stub_request(:get, url).to_return(
+        status: 200, body: '', headers: { 'Content-Type' => 'application/json' }
+      )
+
+      expect {
+        subject.get_file_metadatas(path: request_path, environment: environment)
+      }.to raise_error(Puppet::HTTP::SerializationError, /Failed to deserialize multiple Puppet::FileServing::Metadata from json/)
+    end
+
+    it 'raises response error if path is relative' do
+      expect {
+        subject.get_file_metadatas(path: 'relative_path', environment: environment)
+      }.to raise_error(ArgumentError, 'Path must start with a slash')
+    end
+  end
+
+  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'})
+      end.to_return(status: 200, body: "and beyond")
+
+      expect { |b|
+        subject.get_file_content(path: '/:mount/:path', environment: environment, &b)
+      }.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'])
+
+      expect {
+        subject.get_file_content(path: '/:mount/:path', environment: environment) { |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_file_content(path: 'relative_path', environment: environment) { |data| }
+      }.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

@@ -6,7 +6,7 @@ describe Puppet::HTTP::Service::Report 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(:report) }
-  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:environment) { 'testing' }
   let(:report) { Puppet::Transaction::Report.new }
 
   before :each do
@@ -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(
@@ -72,6 +73,23 @@ describe Puppet::HTTP::Service::Report do
       subject.put_report('infinity', report, environment: environment)
     end
 
+    it 'percent encodes the uri before submitting the report' do
+      stub_request(:put, "https://www.example.com/puppet/v3/report/node%20name?environment=testing")
+        .to_return(status: 200, body: "", headers: {})
+
+      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,38 +1,102 @@
 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
 
+  it "percent encodes paths before appending them to the path" do
+    expect(service.with_base_url('/path/with/a space')).to eq(URI.parse("https://www.example.com/path/with/a%20space"))
+  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
 
@@ -49,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