puppet 6.14.0-x86-mingw32 → 6.19.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
@@ -13,7 +12,7 @@ describe Puppet::HTTP::Service::FileServer do
 
   before :each do
     Puppet[:server] = 'www.example.com'
-    Puppet[:masterport] = 443
+    Puppet[:serverport] = 443
   end
 
   context 'when making requests' do
@@ -32,7 +31,7 @@ describe Puppet::HTTP::Service::FileServer do
   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
+      Puppet[:serverport] = 8141
 
       stub_request(:get, "https://file.example.com:8141/puppet/v3/file_content/:mount/:path?environment=testing")
 
@@ -63,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: {})
 
@@ -136,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(
@@ -148,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
 
@@ -222,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'])
 
@@ -255,6 +279,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_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'])
 

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

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'puppet/http'
+
+describe Puppet::HTTP::Service::Puppetserver 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(:puppetserver) }
+
+  before :each do
+    Puppet[:server] = 'puppetserver.example.com'
+  end
+
+  context 'when making requests' do
+    it 'includes default HTTP headers' do
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master").with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        expect(request.headers).to_not include('X-Puppet-Profiling')
+      end.to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+
+    it 'includes extra headers' do
+      Puppet[:http_extra_headers] = 'region:us-west'
+
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master")
+        .with(headers: {'Region' => 'us-west'})
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+  end
+
+  context 'when routing to the puppetserver service' do
+    it 'defaults the server and port based on settings' do
+      Puppet[:server] = 'compiler2.example.com'
+      Puppet[:serverport] = 8141
+
+      stub_request(:get, "https://compiler2.example.com:8141/status/v1/simple/master")
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+  end
+
+  context 'when getting puppetserver status' do
+    let(:url) { "https://puppetserver.example.com:8140/status/v1/simple/master" }
+
+    it 'returns the request response and status' do
+      stub_request(:get, url)
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      resp, status = subject.get_simple_status
+      expect(resp).to be_a(Puppet::HTTP::Response)
+      expect(status).to eq('running')
+    end
+
+    it 'raises a response error if unsuccessful' do
+      stub_request(:get, url).to_return(status: [500, 'Internal Server Error'])
+
+      expect {
+        subject.get_simple_status
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
+        expect(err.message).to eq("Internal Server Error")
+        expect(err.response.code).to eq(500)
+      end
+    end
+
+    it 'accepts an ssl context' do
+      stub_request(:get, url)
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      other_ctx = Puppet::SSL::SSLContext.new
+      expect(client).to receive(:connect).with(URI(url), options: {ssl_context: other_ctx}).and_call_original
+
+      session = client.create_session
+      service = Puppet::HTTP::Service.create_service(client, session, :puppetserver, 'puppetserver.example.com', 8140)
+      service.get_simple_status(ssl_context: other_ctx)
+    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
@@ -37,11 +36,11 @@ describe Puppet::HTTP::Service::Report do
       subject.put_report('report', report, environment: environment)
     end
 
-    it 'fallbacks to server and masterport' do
+    it 'fallbacks to server and serverport' do
       Puppet[:report_server] = nil
       Puppet[:report_port] = nil
       Puppet[:server] = 'report2.example.com'
-      Puppet[:masterport] = 8142
+      Puppet[:serverport] = 8142
 
       stub_request(:put, "https://report2.example.com:8142/puppet/v3/report/report?environment=testing")
 
@@ -85,7 +84,9 @@ describe Puppet::HTTP::Service::Report do
       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)
+      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

data/spec/unit/http/service_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 require 'puppet/file_serving'
 require 'puppet/file_serving/content'
@@ -17,7 +16,7 @@ describe Puppet::HTTP::Service do
        @client.get(
         url,
         headers: add_puppet_headers({'Default-Header' => 'default-value'}),
-        ssl_context: ssl_context
+        options: {ssl_context: ssl_context}
       )
     end
 
@@ -82,14 +81,14 @@ 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

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,7 +26,7 @@ describe Puppet::HTTP::Session do
       @count = 0
     end
 
-    def resolve(session, name, ssl_context: nil)
+    def resolve(session, name, ssl_context: nil, canceled_handler: nil)
       @count += 1
       return @service if check_connection?(session, @service, ssl_context: ssl_context)
     end
@@ -31,13 +34,11 @@ describe Puppet::HTTP::Session do
 
   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,18 @@ 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: "Connection to #{uri} failed, trying next route: whoops1"),
+                               an_object_having_attributes(level: :err, message: "Connection to #{uri} failed, trying next route: whoops2"))
+    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)
@@ -143,16 +156,15 @@ describe Puppet::HTTP::Session do
       expect(service.url).to eq(URI("https://bar.example.com:8140/puppet-ca/v1"))
     end
 
-    it "fails if server_list doesn't return anything valid" do
-      Puppet[:server_list] = 'foo.example.com,bar.example.com'
+    it "does not fallback from server_list to the settings resolver when server_list is exhausted" do
+      Puppet[:server_list] = 'foo.example.com'
 
-      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record)
+      expect_any_instance_of(Puppet::HTTP::Resolver::Settings).to receive(:resolve).never
       stub_request(:get, "https://foo.example.com:8140/status/v1/simple/master").to_return(status: 500)
-      stub_request(:get, "https://bar.example.com:8140/status/v1/simple/master").to_return(status: 500)
 
       expect {
         session.route_to(:ca)
-      }.to raise_error(Puppet::Error, "Could not select a functional puppet master from server_list: 'foo.example.com,bar.example.com'")
+      }.to raise_error(Puppet::HTTP::RouteError, "No more routes to ca")
     end
 
     it "raises when there are no more routes" do
@@ -166,9 +178,12 @@ describe Puppet::HTTP::Session do
 
     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)
+        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
 
@@ -183,6 +198,27 @@ describe Puppet::HTTP::Session do
 
       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

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

@@ -477,6 +477,7 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     it "should add 'pe_serverversion' when PE" do
+      allow(File).to receive(:readable?).and_call_original
       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

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

@@ -24,7 +24,7 @@ describe Puppet::Resource::Catalog::Json do
     end
 
     before :each do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:server_datadir] = tmpdir('jsondir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
       Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))

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

@@ -10,7 +10,7 @@ describe Puppet::Resource::Catalog::Rest do
 
   before :each do
     Puppet[:server] = 'compiler.example.com'
-    Puppet[:masterport] = 8140
+    Puppet[:serverport] = 8140
 
     described_class.indirection.terminus_class = :rest
   end

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

@@ -9,7 +9,7 @@ describe Puppet::Node::Facts::Rest do
 
   before do
     Puppet[:server] = 'compiler.example.com'
-    Puppet[:masterport] = 8140
+    Puppet[:serverport] = 8140
 
     described_class.indirection.terminus_class = :rest
   end

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

@@ -3,7 +3,87 @@ require 'spec_helper'
 require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::FileBucketFile::Rest do
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    expect(Puppet::FileBucketFile::Rest.superclass).to equal(Puppet::Indirector::REST)
+  let(:rest_path) {"filebucket://xanadu:8141/"}
+  let(:file_bucket_file) {Puppet::FileBucket::File.new('file contents', :bucket_path => '/some/random/path')}
+  let(:files_original_path) {'/path/to/file'}
+  let(:dest_path) {"#{rest_path}#{file_bucket_file.name}/#{files_original_path}"}
+  let(:file_bucket_path) {"#{rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}/#{files_original_path}"}
+  let(:source_path) {"#{rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}"}
+
+  let(:uri) { %r{/puppet/v3/file_bucket_file} }
+
+  describe '#head' do
+    it 'includes the environment as a request parameter' do
+      stub_request(:head, uri).with(query: hash_including(environment: 'outerspace'))
+
+      described_class.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path, environment: Puppet::Node::Environment.remote('outerspace'))
+    end
+
+    it 'includes bucket path in the request if bucket path is set' do
+      stub_request(:head, uri).with(query: hash_including(bucket_path: '/some/random/path'))
+
+      described_class.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path)
+    end
+
+    it "returns nil on 404" do
+      stub_request(:head, uri).to_return(status: 404)
+
+      expect(described_class.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path)).to be_falsy
+    end
+
+    it "raises for all other fail codes" do
+      stub_request(:head, uri).to_return(status: [503, 'server unavailable'])
+
+      expect{described_class.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path)}.to raise_error(Net::HTTPError, "Error 503 on SERVER: server unavailable")
+    end
+  end
+
+  describe '#find' do
+    it 'includes the environment as a request parameter' do
+      stub_request(:get, uri).with(query: hash_including(environment: 'outerspace')).to_return(status: 200, headers: {'Content-Type' => 'application/octet-stream'})
+
+      described_class.indirection.find(source_path, :bucket_path => nil, environment: Puppet::Node::Environment.remote('outerspace'))
+    end
+
+    {bucket_path: 'path', diff_with: '4aabe1257043bd0', list_all: 'true', fromdate: '20200404', todate: '20200404'}.each do |param, val|
+      it "includes #{param} as a parameter in the request if #{param} is set" do
+        stub_request(:get, uri).with(query: hash_including(param => val)).to_return(status: 200, headers: {'Content-Type' => 'application/octet-stream'})
+
+        options = { param => val }
+        described_class.indirection.find(source_path, **options)
+      end
+    end
+
+    it 'raises if unsuccessful' do
+      stub_request(:get, uri).to_return(status: [503, 'server unavailable'])
+
+      expect{described_class.indirection.find(source_path, :bucket_path => nil)}.to raise_error(Net::HTTPError, "Error 503 on SERVER: server unavailable")
+    end
+
+    it 'raises if Content-Type is not included in the response' do
+      stub_request(:get, uri).to_return(status: 200, headers: {})
+
+      expect{described_class.indirection.find(source_path, :bucket_path => nil)}.to raise_error(RuntimeError, "No content type in http response; cannot parse")
+    end
+  end
+
+  describe '#save' do
+    it 'includes the environment as a request parameter' do
+      stub_request(:put, uri).with(query: hash_including(environment: 'outerspace'))
+
+      described_class.indirection.save(file_bucket_file, dest_path, environment: Puppet::Node::Environment.remote('outerspace'))
+    end
+
+    it 'sends the contents of the file as the request body' do
+      stub_request(:put, uri).with(body: file_bucket_file.contents)
+
+      described_class.indirection.save(file_bucket_file, dest_path)
+    end
+
+    it 'raises if unsuccessful' do
+      stub_request(:put, uri).to_return(status: [503, 'server unavailable'])
+
+      expect{described_class.indirection.save(file_bucket_file, dest_path)}.to raise_error(Net::HTTPError, "Error 503 on SERVER: server unavailable")
+    end
   end
 end