puppet 6.11.1-universal-darwin → 6.16.0-universal-darwin

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

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'webmock/rspec'
+require 'puppet/http'
+
+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) { 'testing' }
+  let(:report) { Puppet::Transaction::Report.new }
+
+  before :each do
+    Puppet[:report_server] = 'www.example.com'
+    Puppet[:report_port] = 443
+  end
+
+  context 'when making requests' do
+    let(:uri) {"https://www.example.com:443/puppet/v3/report/report?environment=testing"}
+
+    it 'includes default HTTP headers' do
+      stub_request(:put, 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.put_report('report', report, environment: environment)
+    end
+  end
+
+  context 'when routing to the report service' do
+    it 'defaults the server and port based on settings' do
+      Puppet[:report_server] = 'report.example.com'
+      Puppet[:report_port] = 8141
+
+      stub_request(:put, "https://report.example.com:8141/puppet/v3/report/report?environment=testing")
+
+      subject.put_report('report', report, environment: environment)
+    end
+
+    it 'fallbacks to server and masterport' do
+      Puppet[:report_server] = nil
+      Puppet[:report_port] = nil
+      Puppet[:server] = 'report2.example.com'
+      Puppet[:masterport] = 8142
+
+      stub_request(:put, "https://report2.example.com:8142/puppet/v3/report/report?environment=testing")
+
+      subject.put_report('report', report, environment: environment)
+    end
+  end
+
+  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(
+          headers: {
+            'Accept'=>'application/json, application/x-msgpack, text/pson',
+            'Content-Type'=>'application/json',
+           }).
+         to_return(status: 200, body: "", headers: {})
+
+      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' })
+
+      expect {
+        subject.put_report('infinity', report, 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 an error if unsuccessful, the server version is < 5, and the current serialization format is not pson' do
+      Puppet[:preferred_serialization_format] = 'json'
+
+      stub_request(:put, url).to_return(status: [400, 'Bad Request'], headers: {'X-Puppet-Version' => '4.2.3' })
+
+      expect {
+        subject.put_report('infinity', report, environment: environment)
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ProtocolError)
+        expect(err.message).to eq('To submit reports to a server running puppetserver 4.2.3, set preferred_serialization_format to pson')
+      end
+    end
+  end
+end

data/spec/unit/http/service_spec.rb

@@ -1,32 +1,145 @@
 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, session, :westbound)
+    }.to raise_error(ArgumentError, "Unknown service westbound")
+  end
+
+  [:ca].each do |name|
+    it "returns true for #{name}" do
+      expect(described_class.valid_name?(name)).to eq(true)
+    end
+  end
+
+  it "returns false when the service name is a string" do
+    expect(described_class.valid_name?("ca")).to eq(false)
+  end
+
+  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