puppet 6.27.0 → 7.0.0

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

@@ -11,9 +11,6 @@ def set_facts(fact_hash)
 end
 
 describe Puppet::Resource::Catalog::Compiler do
-  include Matchers::Resource
-  include PuppetSpec::Files
-
   let(:compiler) { described_class.new }
   let(:node_name) { "foo" }
   let(:node) { Puppet::Node.new(node_name)}
@@ -239,46 +236,6 @@ describe Puppet::Resource::Catalog::Compiler do
       expect { compiler.find(@request) }.to raise_error Puppet::Error,
         "Unable to find a common checksum type between agent '' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, :mtime, :ctime, :none]'."
     end
-
-    it "prevents the environment from being evicted during compilation" do
-      Puppet[:environment_timeout] = 0
-
-      envs = Puppet.lookup(:environments)
-
-      expect(compiler).to receive(:compile) do
-        # we should get the same object
-        expect(envs.get!(:production)).to equal(envs.get!(:production))
-      end
-
-      compiler.find(@request)
-    end
-
-    context 'when checking agent and server specified environments' do
-      before :each do
-        FileUtils.mkdir_p(File.join(Puppet[:environmentpath], 'env_server'))
-        FileUtils.mkdir_p(File.join(Puppet[:environmentpath], 'env_agent'))
-
-        node.environment = 'env_server'
-        allow(Puppet::Node.indirection).to receive(:find).and_return(node)
-
-        @request.environment = 'env_agent'
-      end
-
-      it 'ignores mismatched environments by default' do
-        catalog = compiler.find(@request)
-
-        expect(catalog.environment).to eq('env_server')
-        expect(catalog).to have_resource('Stage[main]')
-      end
-
-      it 'returns an empty catalog if asked to check the environment and they are mismatched' do
-        @request.options[:check_environment] = "true"
-        catalog = compiler.find(@request)
-
-        expect(catalog.environment).to eq('env_server')
-        expect(catalog.resources).to be_empty
-      end
-    end
   end
 
   describe "when handling a request with facts" do
@@ -607,50 +564,6 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata
     end
 
-    describe "and the environment is a symlink and versioned_environment_dirs is true" do
-
-      let(:tmpdir) { Dir.mktmpdir }
-
-      before(:each) do
-        Puppet[:versioned_environment_dirs] = true
-        prod_path = File.join(Puppet[:environmentpath], 'production')
-        FileUtils.rm_rf(prod_path)
-        FileUtils.symlink(tmpdir, prod_path)
-      end
-
-      it "inlines metadata for a file" do
-        catalog = compile_to_catalog(<<-MANIFEST, node)
-        file { '#{path}':
-          ensure => file,
-          source => '#{source}'
-        }
-      MANIFEST
-
-        module_relative_path = 'modules/mymodule/files/config_file.txt'
-        metadata = stubs_file_metadata(checksum_type,
-                                       checksum_value,
-                                       module_relative_path,
-                                       File.join(tmpdir, module_relative_path) )
-        expect(metadata).to receive(:source=).with(source)
-        expect(metadata).to receive(:content_uri=).with("puppet:///#{module_relative_path}")
-
-        options = {
-          :environment => catalog.environment_instance,
-          :links => :manage,
-          :checksum_type => checksum_type.to_sym,
-          :source_permissions => :ignore
-        }
-        expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, options).and_return(metadata)
-
-        compiler.send(:inline_metadata, catalog, checksum_type)
-
-
-        expect(catalog.metadata[path]).to eq(metadata)
-        expect(catalog.recursive_metadata).to be_empty
-
-      end
-    end
-
     it "inlines metadata for a file" do
       catalog = compile_to_catalog(<<-MANIFEST, node)
         file { '#{path}':
@@ -996,10 +909,9 @@ describe Puppet::Resource::Catalog::Compiler do
         it "inlines child metadata" do
           catalog = compile_to_catalog(<<-MANIFEST, node)
             file { '#{path}':
-              ensure    => directory,
-              recurse   => true,
-              source    => '#{source_dir}',
-              max_files => 1234,
+              ensure  => directory,
+              recurse => true,
+              source  => '#{source_dir}'
             }
           MANIFEST
 
@@ -1013,7 +925,6 @@ describe Puppet::Resource::Catalog::Compiler do
             :source_permissions => :ignore,
             :recurse            => true,
             :recurselimit       => nil,
-            :max_files          => 1234,
             :ignore             => nil,
           }
           expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source_dir, options).and_return([metadata, child_metadata])
@@ -1027,15 +938,14 @@ describe Puppet::Resource::Catalog::Compiler do
         it "uses resource parameters when inlining metadata" do
           catalog = compile_to_catalog(<<-MANIFEST, node)
             file { '#{path}':
-              ensure             => directory,
-              recurse            => true,
-              source             => '#{source_dir}',
-              checksum           => sha256,
+              ensure  => directory,
+              recurse => true,
+              source  => '#{source_dir}',
+              checksum => sha256,
               source_permissions => use_when_creating,
-              recurselimit       => 2,
-              max_files          => 4321,
-              ignore             => 'foo.+',
-              links              => follow,
+              recurselimit => 2,
+              ignore => 'foo.+',
+              links => follow,
             }
           MANIFEST
 
@@ -1046,7 +956,6 @@ describe Puppet::Resource::Catalog::Compiler do
             :source_permissions => :use_when_creating,
             :recurse            => true,
             :recurselimit       => 2,
-            :max_files          => 4321,
             :ignore             => 'foo.+',
           }
           expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source_dir, options).and_return([metadata, child_metadata])

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

@@ -33,14 +33,6 @@ describe Puppet::Resource::Catalog::Rest do
     described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
   end
 
-  it "passes 'check_environment'" do
-    stub_request(:post, uri)
-      .with(body: hash_including('check_environment' => 'true'))
-      .to_return(**catalog_response(catalog))
-
-    described_class.indirection.find(certname, check_environment: true)
-  end
-
   it 'constructs a catalog environment_instance' do
     env = Puppet::Node::Environment.remote('outerspace')
     catalog = Puppet::Resource::Catalog.new(certname, env)

data/spec/unit/indirector/face_spec.rb

@@ -33,6 +33,7 @@ describe Puppet::Indirector::Face do
   describe "as an instance" do
     it "should be able to determine its indirection" do
       # Loading actions here can get, um, complicated
+      allow(Puppet::Face).to receive(:load_actions)
       expect(Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection).to equal(Puppet::Resource::Catalog.indirection)
     end
   end

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

@@ -22,6 +22,7 @@ describe Puppet::Node::Facts::Facter do
   end
 
   before :each do
+    allow(Puppet::Node::Facts::Facter).to receive(:reload_facter)
     @facter = Puppet::Node::Facts::Facter.new
     allow(Facter).to receive(:to_hash).and_return({})
     @name = "me"
@@ -159,6 +160,8 @@ describe Puppet::Node::Facts::Facter do
     before :each do
       allow(@request).to receive(:options).and_return(options)
       allow(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      allow(Facter).to receive(:respond_to?).and_return(false)
+      allow(Facter).to receive(:respond_to?).with(:resolve).and_return(true)
       allow(facts).to receive(:add_local_facts)
     end
 

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

@@ -18,7 +18,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
     describe "when servicing a save request" do
       it "should return a result whose content is empty" do
         bucket_file = Puppet::FileBucket::File.new('stuff')
-        result = Puppet::FileBucket::File.indirection.save(bucket_file, "md5/c13d88cb4cb02003daedb8a84e5d272a")
+        result = Puppet::FileBucket::File.indirection.save(bucket_file, "sha256/35bafb1ce99aef3ab068afbaabae8f21fd9b9f02d3a9442e364fa92c0b3eeef0")
         expect(result.contents).to be_empty
       end
 
@@ -34,12 +34,14 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         end
         children.each { |child| Process.wait(child) }
 
-        paths = File.read("#{Puppet[:bucketdir]}/9/8/b/f/7/d/8/c/98bf7d8c15784f0a3d63204441e1e2aa/paths").lines.to_a
+        paths = File.read("#{Puppet[:bucketdir]}/d/1/b/2/a/5/9/f/d1b2a59fbea7e20077af9f91b27e95e865061b270be03ff539ab3b73587882e8/paths").lines.to_a
         expect(paths.length).to eq(1)
         expect(Puppet::FileBucket::File.indirection.head("#{bucket_file.checksum_type}/#{bucket_file.checksum_data}/testing")).to be_truthy
       end
 
       it "fails if the contents collide with existing contents" do
+        Puppet[:digest_algorithm] = 'md5'
+
         # This is the shortest known MD5 collision (little endian). See https://eprint.iacr.org/2010/643.pdf
         first_contents = [0x6165300e,0x87a79a55,0xf7c60bd0,0x34febd0b,
                           0x6503cf04,0x854f709e,0xfb0fc034,0x874c9c65,
@@ -66,7 +68,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       context "when the contents file exists but is corrupted and does not match the expected checksum" do
         let(:original_contents) { "a file that will get corrupted" }
         let(:bucket_file) { Puppet::FileBucket::File.new(original_contents) }
-        let(:contents_file) { "#{Puppet[:bucketdir]}/8/e/6/4/f/8/5/d/8e64f85dd54a412f65edabcafe44d491/contents" }
+        let(:contents_file) { "#{Puppet[:bucketdir]}/7/7/4/1/0/2/7/9/77410279bb789b799c2f38bf654b46a509dd27ddad6e47a6684805e9ba390bce/contents" }
 
         before(:each) do
           # Ensure we're starting with a clean slate - no pre-existing backup

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

@@ -5,40 +5,22 @@ require 'puppet/indirector/file_bucket_file/file'
 require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::FileBucketFile::Selector do
-  let(:model) { Puppet::FileBucket::File.new('') }
-  let(:indirection) { Puppet::FileBucket::File.indirection }
-  let(:terminus) { indirection.terminus(:selector) }
-
   %w[head find save search destroy].each do |method|
     describe "##{method}" do
       it "should proxy to rest terminus for https requests" do
-        key = "https://example.com/path/to/file"
+        request = double('request', :protocol => 'https')
 
-        expect(indirection.terminus(:rest)).to receive(method)
+        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(method).with(request)
 
-        if method == 'save'
-          terminus.send(method, indirection.request(method, key, model))
-        else
-          terminus.send(method, indirection.request(method, key, nil))
-        end
+        subject.send(method, request)
       end
 
       it "should proxy to file terminus for other requests" do
-        key = "file:///path/to/file"
-
-        case method
-        when 'save'
-          expect(indirection.terminus(:file)).to receive(method)
-          terminus.send(method, indirection.request(method, key, model))
-        when 'find', 'head'
-          expect(indirection.terminus(:file)).to receive(method)
-          terminus.send(method, indirection.request(method, key, nil))
-        else
-          # file terminus doesn't implement search or destroy
-          expect {
-            terminus.send(method, indirection.request(method, key, nil))
-          }.to raise_error(NoMethodError)
-        end
+        request = double('request', :protocol => 'file')
+
+        expect_any_instance_of(Puppet::FileBucketFile::File).to receive(method).with(request)
+
+        subject.send(method, request)
       end
     end
   end

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

@@ -57,8 +57,4 @@ describe Puppet::Indirector::FileContent::Rest do
 
     described_class.indirection.find("puppet://example.com:8140/:mount/path/to/file")
   end
-
-  it "should use the :fileserver SRV service" do
-    expect(Puppet::Indirector::FileContent::Rest.srv_service).to eq(:fileserver)
-  end
 end

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

@@ -113,8 +113,4 @@ describe Puppet::Indirector::FileMetadata::Rest do
       model.indirection.search("puppet://example.com:8140/:mount/path/to/dir")
     end
   end
-
-  it "should use the :fileserver SRV service" do
-    expect(Puppet::Indirector::FileMetadata::Rest.srv_service).to eq(:fileserver)
-  end
 end

data/spec/unit/indirector/file_server_spec.rb

@@ -246,7 +246,7 @@ describe Puppet::Indirector::FileServer do
   end
 
   describe "when checking authorization" do
-    let(:mount) { double('mount', :empty? => nil, :globalallow? => nil) }
+    let(:mount) { double('mount') }
     let(:request) { Puppet::Indirector::Request.new(:myind, :mymethod, uri, :environment => "myenv") }
 
     before(:each) do
@@ -282,21 +282,7 @@ describe Puppet::Indirector::FileServer do
     end
 
     it "should return true when no auth directives are defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(true)
-      allow(mount).to receive(:globalallow?).and_return(nil)
       expect(terminus).to be_authorized(request)
     end
-
-    it "should return true when a global allow directive is defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(false)
-      allow(mount).to receive(:globalallow?).and_return(true)
-      expect(terminus).to be_authorized(request)
-    end
-
-    it "should return false when a non-global allow directive is defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(false)
-      allow(mount).to receive(:globalallow?).and_return(false)
-      expect(terminus).not_to be_authorized(request)
-    end
   end
 end

data/spec/unit/indirector/indirection_spec.rb

@@ -178,25 +178,29 @@ describe Puppet::Indirector::Indirection do
 
     describe "creates a request" do
       it "should create it with its name as the request's indirection name" do
-        expect(@indirection.request(:funtest, "yayness", nil).indirection_name).to eq(@indirection.name)
+        expect(Puppet::Indirector::Request).to receive(:new).with(@indirection.name, anything, anything)
+        @indirection.request(:funtest, "yayness")
       end
 
       it "should require a method and key" do
-        request = @indirection.request(:funtest, "yayness", nil)
-        expect(request.method).to eq(:funtest)
-        expect(request.key).to eq("yayness")
+        expect(Puppet::Indirector::Request).to receive(:new).with(anything, :funtest, "yayness")
+        @indirection.request(:funtest, "yayness")
       end
 
       it "should support optional arguments" do
-        expect(@indirection.request(:funtest, "yayness", nil, :one => :two).options).to eq(:one => :two)
+        expect(Puppet::Indirector::Request).to receive(:new).with(anything, anything, anything, {:one => :two})
+        @indirection.request(:funtest, "yayness", :one => :two)
       end
 
       it "should not pass options if none are supplied" do
-        expect(@indirection.request(:funtest, "yayness", nil).options).to eq({})
+        expect(Puppet::Indirector::Request).to receive(:new).with(anything, anything, anything)
+        @indirection.request(:funtest, "yayness")
       end
 
       it "should return the request" do
-        expect(@indirection.request(:funtest, "yayness", nil)).to be_a(Puppet::Indirector::Request)
+        request = double('request')
+        expect(Puppet::Indirector::Request).to receive(:new).and_return(request)
+        expect(@indirection.request(:funtest, "yayness")).to equal(request)
       end
     end
 
@@ -499,7 +503,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should return the result of saving to the terminus" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false, :ignore_terminus? => false)
+          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -509,7 +513,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should use a request to save the object to the cache" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false, :ignore_terminus? => false)
+          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -519,7 +523,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should not save to the cache if the normal save fails" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_terminus? => false)
+          request = double('request', :instance => @instance, :node => nil)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -534,13 +538,6 @@ describe Puppet::Indirector::Indirection do
 
           @indirection.save(@instance, '/my/key', :ignore_cache_save => true)
         end
-
-        it "should only save to the cache if the request specifies not to use the terminus" do
-          expect(@terminus).not_to receive(:save)
-          expect(@cache).to receive(:save)
-
-          @indirection.save(@instance, "/my/key", :ignore_terminus => true)
-        end
       end
     end
 
@@ -836,7 +833,7 @@ describe Puppet::Indirector::Indirection do
     end
 
     it "should not create a terminus instance until one is actually needed" do
-      expect(@indirection).not_to receive(:terminus)
+      expect(Puppet::Indirector).not_to receive(:terminus)
       Puppet::Indirector::Indirection.new(double('model'), :lazytest)
     end
 

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

@@ -20,21 +20,6 @@ describe Puppet::Transaction::Report::Rest do
     { body: formatter.render(["store", "http"]), headers: {'Content-Type' => formatter.mime } }
   end
 
-  it "should use the :report_server setting in preference to :server" do
-    Puppet.settings[:server] = "server"
-    Puppet.settings[:report_server] = "report_server"
-    expect(Puppet::Transaction::Report::Rest.server).to eq("report_server")
-  end
-
-  it "should have a value for report_server and report_port" do
-    expect(Puppet::Transaction::Report::Rest.server).not_to be_nil
-    expect(Puppet::Transaction::Report::Rest.port).not_to be_nil
-  end
-
-  it "should use the :report SRV service" do
-    expect(Puppet::Transaction::Report::Rest.srv_service).to eq(:report)
-  end
-
   it "saves a report " do
     stub_request(:put, uri)
       .to_return(status: 200, **report_response)
@@ -77,7 +62,7 @@ describe Puppet::Transaction::Report::Rest do
 
       stub_request(:put, uri)
         .to_return(status: 500,
-                   headers: { 'Content-Type' => 'text/pson', Puppet::Network::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
+                   headers: { 'Content-Type' => 'text/pson', Puppet::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
 
       expect {
         described_class.indirection.save(report)
@@ -89,7 +74,7 @@ describe Puppet::Transaction::Report::Rest do
 
       stub_request(:put, uri)
         .to_return(status: 500,
-                   headers: { 'Content-Type' => 'text/pson', Puppet::Network::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
+                   headers: { 'Content-Type' => 'text/pson', Puppet::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
 
       expect {
         described_class.indirection.save(report)