puppet 6.14.0-universal-darwin → 6.15.0-universal-darwin

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

@@ -63,10 +63,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 +145,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 +166,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 +240,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 +280,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/report_spec.rb

@@ -85,7 +85,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

@@ -17,7 +17,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 +82,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

@@ -10,10 +10,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 +27,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 +60,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)
@@ -166,9 +191,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 +211,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/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

data/spec/unit/network/http/pool_spec.rb

@@ -26,11 +26,11 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   def create_pool
-    Puppet::Network::HTTP::Pool.new
+    Puppet::Network::HTTP::Pool.new(15)
   end
 
   def create_pool_with_connections(site, *connections)
-    pool = Puppet::Network::HTTP::Pool.new
+    pool = Puppet::Network::HTTP::Pool.new(15)
     connections.each do |conn|
       pool.release(site, verifier, conn)
     end
@@ -38,7 +38,7 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   def create_pool_with_http_connections(site, *connections)
-    pool = Puppet::Network::HTTP::Pool.new
+    pool = Puppet::Network::HTTP::Pool.new(15)
     connections.each do |conn|
       pool.release(site, nil, conn)
     end

data/spec/unit/node/environment_spec.rb

@@ -422,6 +422,22 @@ describe Puppet::Node::Environment do
 
             env.modules
           end
+
+          it "includes the Bolt project in modules if it's defined" do
+            path = tmpdir('project')
+            PuppetSpec::Modules.generate_files('bolt_project', path)
+            project = Struct.new("Project", :name, :path).new('bolt_project', path)
+
+            Puppet.override(bolt_project: project) do
+              %w{foo bar}.each do |mod_name|
+                PuppetSpec::Modules.generate_files(mod_name, first_modulepath)
+              end
+              %w{bee baz}.each do |mod_name|
+                PuppetSpec::Modules.generate_files(mod_name, second_modulepath)
+              end
+              expect(env.modules.collect{|mod| mod.name}.sort).to eq(%w{bolt_project foo bar bee baz}.sort)
+            end
+          end
         end
       end
     end

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -33,13 +33,18 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
     let(:user1) { double(:account => 'user1', :domain => '.', :sid => 'user1sid') }
     let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
     let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
+    let(:user_without_domain) { double(:account => 'user_without_domain', :domain => nil, :sid => 'user_without_domain_sid') }
+
     let(:invalid_user) { SecureRandom.uuid }
+    let(:invalid_user_principal) { double(:account => "#{invalid_user}", :domain => nil, :sid => "#{invalid_user}") }
 
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1').and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1', any_args).and_return(user1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(user2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user_without_domain', any_args).and_return(user_without_domain)
       allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user).and_return(nil)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user, true).and_return(invalid_user_principal)
     end
 
     describe "#members_insync?" do
@@ -199,7 +204,15 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
           ]
           expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
         end
+
+      it "should return true even if a current user is unresolvable if should is included" do
+        current = [
+            "#{invalid_user}",
+            'user2',
+          ]
+          expect(provider.members_insync?(current, ['user2'])).to be_truthy
       end
+     end
     end
 
     describe "#members_to_s" do
@@ -222,8 +235,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
         expect(provider.members_to_s(['user1', 'user2'])).to eq('.\user1,.\user2')
       end
 
-      it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
-        expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
+      it "should return a user string without domain if domain is not set" do
+        expect(provider.members_to_s(['user_without_domain'])).to eq('user_without_domain')
       end
 
       it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
@@ -237,10 +250,14 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
     let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
     let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
 
+    let(:invalid_user) { SecureRandom.uuid }
+    let(:invalid_user_principal) { double(:account => "#{invalid_user}", :domain => nil, :sid => "#{invalid_user}") }
+
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1').and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1', any_args).and_return(user1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(user2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user, true).and_return(invalid_user_principal)
 
       resource[:auth_membership] = true
     end
@@ -261,6 +278,22 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
       expect(provider.members).to match_array(expected_members)
     end
 
+    it "should be able to handle unresolvable SID in list of members" do
+      allow(provider.group).to receive(:members).and_return([
+        'user1',
+        "#{invalid_user}",
+        'user3',
+      ])
+
+      expected_member_sids = [user1.sid, invalid_user_principal.sid, user3.sid]
+      expected_members = ['user1', "#{invalid_user}", 'user3']
+      allow(provider).to receive(:members_to_s)
+        .with(expected_member_sids)
+        .and_return(expected_members.join(','))
+
+      expect(provider.members).to match_array(expected_members)
+    end
+
     it "should be able to set group members" do
       allow(provider.group).to receive(:members).and_return(['user1', 'user2'])
 
@@ -272,8 +305,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
 
       allow(provider.group).to receive(:member_sids).and_return(member_sids[0..1])
 
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(member_sids[1])
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(member_sids[2])
+      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(member_sids[1])
+      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(member_sids[2])
 
       expect(provider.group).to receive(:remove_member_sids).with(member_sids[0])
       expect(provider.group).to receive(:add_member_sids).with(member_sids[2])