puppet 5.5.18-x64-mingw32 → 5.5.19-x64-mingw32

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

@@ -9,19 +9,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)
-      expect(Facter).to receive(:value).with('fqdn').and_return("my.server.com")
-      expect(Facter).to receive(:value).with('ipaddress').and_return("my.ip.address")
-    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
@@ -38,8 +28,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)
@@ -246,10 +234,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)
@@ -267,6 +255,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
@@ -276,21 +266,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)
@@ -298,7 +288,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 {
@@ -308,15 +298,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
 
@@ -328,7 +320,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
@@ -336,7 +328,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)
 
@@ -414,9 +405,37 @@ 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).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

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

@@ -135,7 +135,7 @@ describe Puppet::Network::HTTP::Connection do
   end
 
   context "when response indicates an overloaded server" do
-    let(:http) { double('http') }
+    let(:http) { double('http', :started? => true) }
     let(:site) { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
     let(:verify) { Puppet::SSL::Validator.no_validator }
     let(:httpunavailable) { Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable') }
@@ -158,6 +158,7 @@ describe Puppet::Network::HTTP::Connection do
 
       pool = Puppet.lookup(:http_pool)
       expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+      allow(http).to receive(:finish)
 
       result = subject.get('/foo')
 
@@ -167,6 +168,7 @@ describe Puppet::Network::HTTP::Connection do
     it "should return a 503 response if Retry-After is not convertible to an Integer or RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'foo'
       allow(http).to receive(:request).and_return(httpunavailable)
+      allow(http).to receive(:finish)
 
       pool = Puppet.lookup(:http_pool)
       expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
@@ -176,9 +178,21 @@ describe Puppet::Network::HTTP::Connection do
       expect(result.code).to eq(503)
     end
 
+    it "should close the connection before sleeping" do
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
+
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+
+      expect(http).to receive(:finish)
+
+      subject.get('/foo')
+    end
+
     it "should sleep and retry if Retry-After is an Integer" do
       httpunavailable['Retry-After'] = '42'
       allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      allow(http).to receive(:finish)
 
       pool = Puppet.lookup(:http_pool)
       expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
@@ -193,6 +207,7 @@ describe Puppet::Network::HTTP::Connection do
     it "should sleep and retry if Retry-After is an RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'Wed, 13 Apr 2005 15:18:05 GMT'
       allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      allow(http).to receive(:finish)
 
       now = DateTime.new(2005, 4, 13, 8, 17, 5, '-07:00')
       allow(DateTime).to receive(:now).and_return(now)
@@ -210,6 +225,7 @@ describe Puppet::Network::HTTP::Connection do
     it "should sleep for no more than the Puppet runinterval" do
       httpunavailable['Retry-After'] = '60'
       allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      allow(http).to receive(:finish)
       Puppet[:runinterval] = 30
 
       pool = Puppet.lookup(:http_pool)

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

@@ -60,6 +60,8 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'returns the connection to the pool' do
       conn = create_connection(site)
+      expect(conn).to receive(:started?).and_return(true)
+
       pool = create_pool
       pool.release(site, conn)
 
@@ -137,6 +139,7 @@ describe Puppet::Network::HTTP::Pool do
       it 'releases HTTP connections' do
         conn = create_connection(site)
         expect(conn).to receive(:use_ssl?).and_return(false)
+        expect(conn).to receive(:started?).and_return(true)
 
         pool = create_pool_with_connections(site, conn)
         expect(pool).to receive(:release).with(site, conn)
@@ -148,6 +151,7 @@ describe Puppet::Network::HTTP::Pool do
         conn = create_connection(site)
         expect(conn).to receive(:use_ssl?).and_return(true)
         expect(conn).to receive(:verify_mode).and_return(OpenSSL::SSL::VERIFY_PEER)
+        expect(conn).to receive(:started?).and_return(true)
 
         pool = create_pool_with_connections(site, conn)
         expect(pool).to receive(:release).with(site, conn)
@@ -166,6 +170,19 @@ describe Puppet::Network::HTTP::Pool do
 
         pool.with_connection(site, verify) {|c| }
       end
+
+      it "doesn't add a closed  connection back to the pool" do
+        http = Net::HTTP.new(site.addr)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.start
+
+        pool = create_pool_with_connections(site, http)
+
+        pool.with_connection(site, verify) {|c| c.finish}
+
+        expect(pool.pool[site]).to be_empty
+      end
     end
   end
 
@@ -228,6 +245,7 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'finishes expired connections' do
       conn = create_connection(site)
+      allow(conn).to receive(:started?).and_return(true)
       expect(conn).to receive(:finish)
 
       pool = create_pool_with_expired_connections(site, conn)
@@ -241,6 +259,7 @@ describe Puppet::Network::HTTP::Pool do
       expect(Puppet).to receive(:log_exception).with(be_a(IOError), "Failed to close connection for #{site}: read timeout")
 
       conn = create_connection(site)
+      expect(conn).to receive(:started?).and_return(true)
       expect(conn).to receive(:finish).and_raise(IOError, 'read timeout')
 
       pool = create_pool_with_expired_connections(site, conn)
@@ -289,10 +308,23 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'closes all cached connections' do
       conn = create_connection(site)
+      allow(conn).to receive(:started?).and_return(true)
       expect(conn).to receive(:finish)
 
       pool = create_pool_with_connections(site, conn)
       pool.close
     end
+
+    it 'allows a connection to be closed multiple times safely' do
+      http = Net::HTTP.new(site.addr)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.start
+
+      pool = create_pool
+
+      expect(pool.close_connection(site, http)).to eq(true)
+      expect(pool.close_connection(site, http)).to eq(false)
+    end
   end
 end

data/spec/unit/node_spec.rb

@@ -414,7 +414,9 @@ end
 
 describe Puppet::Node, "when generating the list of names to search through" do
   before do
-    @node = Puppet::Node.new("foo.domain.com", :parameters => {"hostname" => "yay", "domain" => "domain.com"})
+    Puppet[:strict_hostname_checking] = false
+    @node = Puppet::Node.new("foo.domain.com",
+                             :parameters => {"hostname" => "yay", "domain" => "domain.com"})
   end
 
   it "returns an array of names" do
@@ -445,7 +447,6 @@ describe Puppet::Node, "when generating the list of names to search through" do
 
   describe "and :node_name is set to 'cert'" do
     before do
-      Puppet[:strict_hostname_checking] = false
       Puppet[:node_name] = "cert"
     end
 
@@ -454,8 +455,11 @@ describe Puppet::Node, "when generating the list of names to search through" do
     end
 
     describe "and strict hostname checking is enabled" do
-      it "only uses the passed-in key" do
+      before do
         Puppet[:strict_hostname_checking] = true
+      end
+
+      it "only uses the passed-in key" do
         expect(@node.names).to eq(["foo.domain.com"])
       end
     end
@@ -463,7 +467,6 @@ describe Puppet::Node, "when generating the list of names to search through" do
 
   describe "and :node_name is set to 'facter'" do
     before do
-      Puppet[:strict_hostname_checking] = false
       Puppet[:node_name] = "facter"
     end
 

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

@@ -47,7 +47,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
         described_class.has_feature(:libuser)
         resource[:forcelocal] = :true
       end
- 
+
       it "should use lgroupadd instead of groupadd" do
         expect(provider).to receive(:execute).with(including('/usr/sbin/lgroupadd'), hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
         provider.create
@@ -124,6 +124,35 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
     end
   end
 
+  describe "#findgroup" do
+    before { allow(File).to receive(:read).with('/etc/group').and_return(content) }
+
+    let(:content) { "sample_group_name:sample_password:sample_gid:sample_user_list" }
+    let(:output) do
+      {
+        group_name: 'sample_group_name',
+        password: 'sample_password',
+        gid: 'sample_gid',
+        user_list: 'sample_user_list',
+      }
+    end
+
+    [:group_name, :password, :gid, :user_list].each do |key|
+      it "finds a group by #{key} when asked" do
+        expect(provider.send(:findgroup, key, "sample_#{key}")).to eq(output)
+      end
+    end
+
+    it "returns false when specified key/value pair is not found" do
+      expect(provider.send(:findgroup, :group_name, 'invalid_group_name')).to eq(false)
+    end
+
+    it "reads the group file only once per resource" do
+      expect(File).to receive(:read).with('/etc/group').once
+      5.times { provider.send(:findgroup, :group_name, 'sample_group_name') }
+    end
+  end
+
   describe "#delete" do
     before do
       allow(provider).to receive(:exists?).and_return(true)

data/spec/unit/provider/package/apt_spec.rb

@@ -32,12 +32,14 @@ describe Puppet::Type.type(:package).provider(:apt) do
 
   it "should use 'apt-get remove' to uninstall" do
     expect(provider).to receive(:aptget).with("-y", "-q", :remove, name)
+    expect(provider).to receive(:properties).and_return({:mark => :none})
     provider.uninstall
   end
 
   it "should use 'apt-get purge' and 'dpkg purge' to purge" do
     expect(provider).to receive(:aptget).with("-y", "-q", :remove, "--purge", name)
     expect(provider).to receive(:dpkg).with("--purge", name)
+    expect(provider).to receive(:properties).and_return({:mark => :none})
     provider.purge
   end
 
@@ -88,14 +90,14 @@ Version table:
     it "should preseed if a responsefile is provided" do
       resource[:responsefile] = "/my/file"
       expect(provider).to receive(:run_preseed)
-
+      expect(provider).to receive(:properties).and_return({:mark => :none})
       allow(provider).to receive(:aptget)
       provider.install
     end
 
     it "should check for a cdrom" do
       expect(provider).to receive(:checkforcdrom)
-
+      expect(provider).to receive(:properties).and_return({:mark => :none})
       allow(provider).to receive(:aptget)
       provider.install
     end
@@ -106,6 +108,7 @@ Version table:
         expect(command[-1]).to eq(name)
         expect(command[-2]).to eq(:install)
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -115,6 +118,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command[-1]).to eq("#{name}=1.0")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -124,6 +128,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("--force-yes")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -132,6 +137,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("-q")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -140,6 +146,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("-y")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -149,6 +156,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("DPkg::Options::=--force-confold")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -158,6 +166,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("DPkg::Options::=--force-confnew")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -165,6 +174,7 @@ Version table:
     it 'should support string install options' do
       resource[:install_options] = ['--foo', '--bar']
       expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -172,6 +182,7 @@ Version table:
     it 'should support hash install options' do
       resource[:install_options] = ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
       expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end