puppet 6.12.0-universal-darwin → 6.13.0-universal-darwin

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

@@ -0,0 +1,219 @@
+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
+
+    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
+    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 '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 '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 '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 '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 '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 '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
+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
@@ -72,6 +72,13 @@ 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 '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

@@ -17,6 +17,10 @@ describe Puppet::HTTP::Service do
     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)
 

data/spec/unit/http/session_spec.rb

@@ -73,6 +73,37 @@ describe Puppet::HTTP::Session do
         session.route_to(:westbound)
       }.to raise_error(ArgumentError, "Unknown service westbound")
     end
+
+    it 'routes to the service when given a puppet URL with an explicit host' do
+      allow_any_instance_of(Net::HTTP).to receive(:start)
+
+      session = described_class.new(client, [])
+      url = URI("puppet://example.com:8140/:modules/:module/path/to/file")
+      service = session.route_to(:fileserver, url: url)
+
+      expect(service.url.to_s).to eq("https://example.com:8140/puppet/v3")
+    end
+
+    it 'raises a connection error if we cannot connect' do
+      allow_any_instance_of(Net::HTTP).to receive(:start).and_raise(Net::OpenTimeout)
+
+      session = described_class.new(client, [])
+      url = URI('puppet://example.com:8140/:modules/:module/path/to/file')
+
+      expect {
+        session.route_to(:fileserver, url: url)
+      }.to raise_error(Puppet::HTTP::ConnectionError,
+                       %r{Request to https://example.com:8140/puppet/v3 timed out connect operation after .* seconds})
+    end
+
+    it 'resolves the route when given a generic puppet:/// URL' do
+      resolvers = [DummyResolver.new(good_service)]
+      session = described_class.new(client, resolvers)
+      url = URI('puppet:///:modules/:module/path/to/file')
+      service = session.route_to(:fileserver, url: url)
+
+      expect(service.url).to eq(good_service.url)
+    end
   end
 
   context 'when resolving using multiple resolvers' do

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

@@ -15,22 +15,9 @@ describe Puppet::Resource::Catalog::Compiler do
   let(:node_name) { "foo" }
   let(:node) { Puppet::Node.new(node_name)}
 
-  before do
-    allow(Facter).to receive(:to_hash).and_return({})
-  end
-
   describe "when initializing" do
     before do
-      expect(Puppet).to receive(:version).and_return(1)
-      set_facts({
-        'fqdn'       => "my.server.com",
-        'ipaddress'  => "my.ip.address",
-        'ipaddress6' => nil
-        })
-    end
-
-    it "should gather data about itself" do
-      Puppet::Resource::Catalog::Compiler.new
+      allow(Puppet).to receive(:version).and_return(1)
     end
 
     it "should cache the server metadata and reuse it" do
@@ -47,8 +34,6 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when finding catalogs" do
     before do
-      allow(Facter).to receive(:value).and_return("whatever")
-
       allow(node).to receive(:merge)
       allow(Puppet::Node.indirection).to receive(:find).and_return(node)
       @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil, :node => node_name)
@@ -255,10 +240,10 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when handling a request with facts" do
     before do
-      Puppet::Node::Facts.indirection.terminus_class = :memory
       allow(Facter).to receive(:value).and_return("something")
 
-      @facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
+      facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
+      Puppet::Node::Facts.indirection.save(facts)
     end
 
     def a_legacy_request_that_contains(facts, format = :pson)
@@ -276,6 +261,8 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     context "when extracting facts from the request" do
+      let(:facts) { Puppet::Node::Facts.new("hostname") }
+
       it "should do nothing if no facts are provided" do
         request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
         request.options[:facts] = nil
@@ -285,21 +272,21 @@ describe Puppet::Resource::Catalog::Compiler do
 
       it "should deserialize the facts without changing the timestamp" do
         time = Time.now
-        @facts.timestamp = time
-        request = a_request_that_contains(@facts)
+        facts.timestamp = time
+        request = a_request_that_contains(facts)
         facts = compiler.extract_facts_from_request(request)
         expect(facts.timestamp).to eq(time)
       end
 
       it "accepts PSON facts from older agents" do
-        request = a_legacy_request_that_contains(@facts)
+        request = a_legacy_request_that_contains(facts)
 
         facts = compiler.extract_facts_from_request(request)
-        expect(facts).to eq(@facts)
+        expect(facts).to eq(facts)
       end
 
       it "rejects YAML facts" do
-        request = a_legacy_request_that_contains(@facts, :yaml)
+        request = a_legacy_request_that_contains(facts, :yaml)
 
         expect {
           compiler.extract_facts_from_request(request)
@@ -307,7 +294,7 @@ describe Puppet::Resource::Catalog::Compiler do
       end
 
       it "rejects unknown fact formats" do
-        request = a_request_that_contains(@facts)
+        request = a_request_that_contains(facts)
         request.options[:facts_format] = 'unknown-format'
 
         expect {
@@ -317,15 +304,17 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     context "when saving facts from the request" do
+      let(:facts) { Puppet::Node::Facts.new("hostname") }
+
       it "should save facts if they were issued by the request" do
-        request = a_request_that_contains(@facts)
+        request = a_request_that_contains(facts)
 
         options = {
           :environment => request.environment,
           :transaction_uuid => request.options[:transaction_uuid],
         }
 
-        expect(Puppet::Node::Facts.indirection).to receive(:save).with(@facts, nil, options)
+        expect(Puppet::Node::Facts.indirection).to receive(:save).with(facts, nil, options)
         compiler.find(request)
       end
 
@@ -337,7 +326,7 @@ describe Puppet::Resource::Catalog::Compiler do
           :transaction_uuid => request.options[:transaction_uuid],
         }
 
-        expect(Puppet::Node::Facts.indirection).not_to receive(:save).with(@facts, nil, options)
+        expect(Puppet::Node::Facts.indirection).not_to receive(:save).with(facts, nil, options)
         compiler.find(request)
       end
     end
@@ -345,7 +334,6 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when finding nodes" do
     it "should look node information up via the Node class with the provided key" do
-      allow(Facter).to receive(:value).and_return("whatever")
       request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
       allow(compiler).to receive(:compile)
 
@@ -471,9 +459,38 @@ describe Puppet::Resource::Catalog::Compiler do
     end
   end
 
+  describe "after finding nodes when checking for a PE version" do
+    include PuppetSpec::Compiler
+
+    let(:pe_version_file) { '/opt/puppetlabs/server/pe_version' }
+    let(:request) { Puppet::Indirector::Request.new(:catalog, :find, node_name, nil) }
+
+    before :each do
+      Puppet[:code] = 'notify { "PE Version: $pe_serverversion": }'
+    end
+
+    it "should not add 'pe_serverversion' when FOSS" do
+      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
+      catalog = compiler.find(request)
+
+      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be_nil
+    end
+
+    it "should add 'pe_serverversion' when PE" do
+      allow(File).to receive(:readable?).with(pe_version_file).and_return(true)
+      allow(File).to receive(:zero?).with(pe_version_file).and_return(false)
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(pe_version_file).and_return('2019.2.0')
+
+      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
+      catalog = compiler.find(request)
+
+      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be
+    end
+  end
+
   describe "when filtering resources" do
     before :each do
-      allow(Facter).to receive(:value)
       @catalog = double('catalog')
       allow(@catalog).to receive(:respond_to?).with(:filter).and_return(true)
     end