puppet 6.25.0-x64-mingw32 → 7.0.0-x64-mingw32

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

@@ -1,4 +1,3 @@
-
 # coding: utf-8
 require 'spec_helper'
 require 'puppet/http'
@@ -12,7 +11,6 @@ describe Puppet::HTTP::Service::Compiler do
   let(:node) { Puppet::Node.new(certname) }
   let(:facts) { Puppet::Node::Facts.new(certname) }
   let(:catalog) { Puppet::Resource::Catalog.new(certname) }
-  let(:status) { Puppet::Status.new }
   let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
 
   before :each do
@@ -96,14 +94,6 @@ describe Puppet::HTTP::Service::Compiler do
       subject.post_catalog(certname, environment: 'production', facts: facts, configured_environment: 'agent_specified')
     end
 
-    it 'includes check_environment' do
-      stub_request(:post, uri)
-        .with(body: hash_including('check_environment' => 'false'))
-        .to_return(**catalog_response)
-
-      subject.post_catalog(certname, environment: 'production', facts: facts)
-    end
-
     it 'includes transaction_uuid' do
       uuid = "ec3d2844-b236-4287-b0ad-632fbb4d1ff0"
 
@@ -267,128 +257,6 @@ describe Puppet::HTTP::Service::Compiler do
     end
   end
 
-  context 'when posting for a v4 catalog' do
-    let(:uri) {"https://compiler.example.com:8140/puppet/v4/catalog"}
-    let(:persistence) {{ facts: true, catalog: true }}
-    let(:facts) {{ 'foo' => 'bar' }}
-    let(:trusted_facts) {{}}
-    let(:uuid) { "ec3d2844-b236-4287-b0ad-632fbb4d1ff0" }
-    let(:job_id) { "1" }
-    let(:payload) {{
-      environment: environment,
-      persistence: persistence,
-      facts: facts,
-      trusted_facts: trusted_facts,
-      transaction_uuid: uuid,
-      job_id: job_id,
-      options: {
-        prefer_requested_environment: false,
-        capture_logs: false
-      }
-    }}
-    let(:serialized_catalog) {{ 'catalog' => catalog.to_data_hash }.to_json}
-    let(:catalog_response) {{ body: serialized_catalog, headers: {'Content-Type' => formatter.mime }}}
-
-    it 'includes default HTTP headers' do
-      stub_request(:post, uri).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(**catalog_response)
-
-      subject.post_catalog4(certname, **payload)
-    end
-
-    it 'defaults the server and port based on settings' do
-      Puppet[:server] = 'compiler2.example.com'
-      Puppet[:serverport] = 8141
-
-      stub_request(:post, "https://compiler2.example.com:8141/puppet/v4/catalog")
-        .to_return(**catalog_response)
-
-      subject.post_catalog4(certname, **payload)
-    end
-
-    it 'includes puppet headers set via the :http_extra_headers and :profile settings' do
-      stub_request(:post, uri).with(headers: {'Example-Header' => 'real-thing', 'another' => 'thing', 'X-Puppet-Profiling' => 'true'}).
-        to_return(**catalog_response)
-
-      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
-      Puppet[:profile] = true
-
-      subject.post_catalog4(certname, **payload)
-    end
-
-    it 'returns a deserialized catalog' do
-      stub_request(:post, uri)
-        .to_return(**catalog_response)
-
-      _, cat, _ = subject.post_catalog4(certname, **payload)
-      expect(cat).to be_a(Puppet::Resource::Catalog)
-      expect(cat.name).to eq(certname)
-    end
-
-    it 'returns the request response' do
-      stub_request(:post, uri)
-        .to_return(**catalog_response)
-
-      resp, _, _ = subject.post_catalog4(certname, **payload)
-      expect(resp).to be_a(Puppet::HTTP::Response)
-    end
-
-    it 'raises a response error if unsuccessful' do
-      stub_request(:post, uri)
-        .to_return(status: [500, "Server Error"])
-
-      expect {
-        subject.post_catalog4(certname, **payload)
-      }.to raise_error do |err|
-        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
-        expect(err.message).to eq('Server Error')
-        expect(err.response.code).to eq(500)
-      end
-    end
-
-    it 'raises a response error when server response is not JSON' do
-      stub_request(:post, uri)
-        .to_return(body: "this isn't valid JSON", headers: {'Content-Type' => 'application/json'})
-
-      expect {
-        subject.post_catalog4(certname, **payload)
-      }.to raise_error do |err|
-        expect(err).to be_an_instance_of(Puppet::HTTP::SerializationError)
-        expect(err.message).to match(/Failed to deserialize catalog from puppetserver response/)
-      end
-    end
-
-    it 'raises a response error when server response a JSON serialized catalog' do
-      stub_request(:post, uri)
-        .to_return(body: {oops: 'bad response data'}.to_json, headers: {'Content-Type' => 'application/json'})
-
-      expect {
-        subject.post_catalog4(certname, **payload)
-      }.to raise_error do |err|
-        expect(err).to be_an_instance_of(Puppet::HTTP::SerializationError)
-        expect(err.message).to match(/Failed to deserialize catalog from puppetserver response/)
-      end
-    end
-
-    it 'raises ArgumentError when the `persistence` hash does not contain required keys' do
-      payload[:persistence].delete(:facts)
-      expect { subject.post_catalog4(certname, **payload) }.to raise_error do |err|
-        expect(err).to be_an_instance_of(ArgumentError)
-        expect(err.message).to match(/The 'persistence' hash is missing the keys: facts/)
-      end
-    end
-
-    it 'raises ArgumentError when `facts` are not a Hash' do
-      payload[:facts] = Puppet::Node::Facts.new(certname)
-      expect { subject.post_catalog4(certname, **payload) }.to raise_error do |err|
-        expect(err).to be_an_instance_of(ArgumentError)
-        expect(err.message).to match(/Facts must be a Hash not a Puppet::Node::Facts/)
-      end
-    end
-  end
-
   context 'when getting a node' do
     let(:uri) { %r{/puppet/v3/node/ziggy} }
     let(:node_response) { { body: formatter.render(node), headers: {'Content-Type' => formatter.mime } } }
@@ -597,67 +465,6 @@ describe Puppet::HTTP::Service::Compiler do
     end
   end
 
-  context 'when getting status' do
-    let(:uri) { %r{/puppet/v3/status/ziggy} }
-    let(:status_response) { { body: formatter.render(status), headers: {'Content-Type' => formatter.mime } } }
-
-    it 'always sends production' do
-      stub_request(:get, uri)
-          .with(query: hash_including("environment" => "production"))
-          .to_return(**status_response)
-
-      subject.get_status(certname)
-    end
-
-    it 'returns a deserialized status' do
-      stub_request(:get, uri)
-        .to_return(**status_response)
-
-      _, s = subject.get_status(certname)
-      expect(s).to be_a(Puppet::Status)
-      expect(s.status).to eq("is_alive" => true)
-    end
-
-    it 'returns the request response' do
-      stub_request(:get, uri)
-        .to_return(**status_response)
-
-      resp, _ = subject.get_status(certname)
-      expect(resp).to be_a(Puppet::HTTP::Response)
-    end
-
-    it 'raises a response error if unsuccessful' do
-      stub_request(:get, uri)
-        .to_return(status: [500, "Server Error"])
-
-      expect {
-        subject.get_status(certname)
-      }.to raise_error do |err|
-        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
-        expect(err.message).to eq('Server Error')
-        expect(err.response.code).to eq(500)
-      end
-    end
-
-    it 'raises a protocol error if the content-type header is missing' do
-      stub_request(:get, uri)
-        .to_return(body: "content-type is missing")
-
-      expect {
-        subject.get_status(certname)
-      }.to raise_error(Puppet::HTTP::ProtocolError, /No content type in http response; cannot parse/)
-    end
-
-    it 'raises a serialization error if the content is invalid' do
-      stub_request(:get, uri)
-        .to_return(body: "this isn't valid JSON", headers: {'Content-Type' => 'application/json'})
-
-      expect {
-        subject.get_status(certname)
-      }.to raise_error(Puppet::HTTP::SerializationError, /Failed to deserialize Puppet::Status from json/)
-    end
-  end
-
   context 'filebucket' do
     let(:filebucket_file) { Puppet::FileBucket::File.new('file to store') }
     let(:formatter) { Puppet::Network::FormatHandler.format(:binary) }

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

@@ -41,7 +41,7 @@ describe Puppet::HTTP::Service::FileServer do
 
   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(:url) { "https://www.example.com/puppet/v3/file_metadata/:mount/#{path}?checksum_type=sha256&environment=testing&links=manage&source_permissions=ignore" }
     let(:filemetadata) { Puppet::FileServing::Metadata.new(path) }
     let(:request_path) { "/:mount/#{path}"}
 
@@ -122,7 +122,7 @@ describe Puppet::HTTP::Service::FileServer do
 
   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(:url) { "https://www.example.com/puppet/v3/file_metadatas/:mount/#{path}?checksum_type=sha256&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}"}
@@ -158,7 +158,7 @@ describe Puppet::HTTP::Service::FileServer do
     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"
+      url = "https://www.example.com/puppet/v3/file_metadatas/:mount/#{path}?checksum_type=sha256&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(

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

@@ -12,7 +12,7 @@ describe Puppet::HTTP::Service::Puppetserver do
 
   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|
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/server").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'})
@@ -23,7 +23,7 @@ describe Puppet::HTTP::Service::Puppetserver do
     it 'includes extra headers' do
       Puppet[:http_extra_headers] = 'region:us-west'
 
-      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master")
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/server")
         .with(headers: {'Region' => 'us-west'})
         .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
 
@@ -36,7 +36,7 @@ describe Puppet::HTTP::Service::Puppetserver do
       Puppet[:server] = 'compiler2.example.com'
       Puppet[:serverport] = 8141
 
-      stub_request(:get, "https://compiler2.example.com:8141/status/v1/simple/master")
+      stub_request(:get, "https://compiler2.example.com:8141/status/v1/simple/server")
         .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
 
       subject.get_simple_status
@@ -44,7 +44,7 @@ describe Puppet::HTTP::Service::Puppetserver do
   end
 
   context 'when getting puppetserver status' do
-    let(:url) { "https://puppetserver.example.com:8140/status/v1/simple/master" }
+    let(:url) { "https://puppetserver.example.com:8140/status/v1/simple/server" }
 
     it 'returns the request response and status' do
       stub_request(:get, url)
@@ -79,4 +79,34 @@ describe Puppet::HTTP::Service::Puppetserver do
       service.get_simple_status(ssl_context: other_ctx)
     end
   end
+
+  context 'when /status/v1/simple/server returns not found' do
+    it 'calls /status/v1/simple/master' do
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/server")
+        .to_return(status: [404, 'not found: server'])
+
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master")
+        .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 fallback is unsuccessful' do
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/server")
+        .to_return(status: [404, 'not found: server'])
+
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master")
+        .to_return(status: [404, 'not found: master'])
+
+      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('not found: master')
+        expect(err.response.code).to eq(404)
+      end
+    end
+  end
 end

data/spec/unit/http/service_spec.rb

@@ -126,7 +126,6 @@ describe Puppet::HTTP::Service do
       Puppet::Node::Facts,
       Puppet::Transaction::Report,
       Puppet::FileServing::Metadata,
-      Puppet::Status
     ].each do |model|
       expect(service.mime_types(model)).to eq(mimes)
     end

data/spec/unit/http/session_spec.rb

@@ -127,7 +127,7 @@ describe Puppet::HTTP::Session do
       Puppet[:server_list] = 'foo.example.com,bar.example.com,baz.example.com'
       Puppet[:ca_server] = 'caserver.example.com'
 
-      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record).and_yield('mars.example.srv', 8140)
+      allow_any_instance_of(Puppet::HTTP::DNS).to receive(:each_srv_record).and_yield('mars.example.srv', 8140)
       service = session.route_to(:ca)
 
       expect(service.url).to eq(URI("https://mars.example.srv:8140/puppet-ca/v1"))
@@ -147,9 +147,9 @@ describe Puppet::HTTP::Session do
       Puppet[:use_srv_records] = true
       Puppet[:server_list] = 'foo.example.com,bar.example.com,baz.example.com'
 
-      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record)
-      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: 200)
+      allow_any_instance_of(Puppet::HTTP::DNS).to receive(:each_srv_record)
+      stub_request(:get, "https://foo.example.com:8140/status/v1/simple/server").to_return(status: 500)
+      stub_request(:get, "https://bar.example.com:8140/status/v1/simple/server").to_return(status: 200)
 
       service = session.route_to(:ca)
 
@@ -160,7 +160,7 @@ describe Puppet::HTTP::Session do
       Puppet[:server_list] = 'foo.example.com'
 
       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://foo.example.com:8140/status/v1/simple/server").to_return(status: 500)
 
       expect {
         session.route_to(:ca)
@@ -179,7 +179,7 @@ describe Puppet::HTTP::Session do
     Puppet::HTTP::Service::SERVICE_NAMES.each do |name|
       it "resolves #{name} using server_list" do
         Puppet[:server_list] = 'apple.example.com'
-        req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+        req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/server").to_return(status: 200)
 
         session.route_to(name)
 
@@ -201,7 +201,7 @@ describe Puppet::HTTP::Session do
 
     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)
+      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/server").to_return(status: 200)
 
       Puppet::HTTP::Service::SERVICE_NAMES.each do |name|
         session.route_to(name)
@@ -212,7 +212,7 @@ describe Puppet::HTTP::Session do
 
     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)
+      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/server").to_return(status: 200)
 
       client.create_session.route_to(:puppet)
       client.create_session.route_to(:puppet)
@@ -222,6 +222,8 @@ describe Puppet::HTTP::Session do
   end
 
   context 'when retrieving capabilities' do
+    let(:response) { Puppet::HTTP::Response.new(uri, 200, 'OK') }
+
     let(:session) do
       resolver = DummyResolver.new(good_service)
       described_class.new(client, [resolver])
@@ -242,7 +244,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "supports locales if the cached service's version is 5.3.4 or greater" do
-        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.3.4'}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return('5.3.4')
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -251,7 +253,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "does not support locales if the cached service's version is 5.3.3" do
-        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.3.3'}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return('5.3.3')
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -260,7 +262,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "does not support locales if the cached service's version is missing" do
-        response = Puppet::HTTP::Response.new({}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return(nil)
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -277,7 +279,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "supports json if the cached service's version is 5 or greater" do
-        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.5.12'}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return('5.5.12')
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -286,7 +288,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "does not support json if the cached service's version is less than 5.0" do
-        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '4.10.1'}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return('4.10.1')
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -295,7 +297,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "supports json if the cached service's version is missing" do
-        response = Puppet::HTTP::Response.new({}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return(nil)
 
         session.route_to(:puppet)
         session.process_response(response)

data/spec/unit/{network/http → http}/site_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-require 'puppet/network/http'
+require 'puppet/http'
 
-describe Puppet::Network::HTTP::Site do
+describe Puppet::HTTP::Site do
   let(:scheme)      { 'https' }
   let(:host)        { 'rubygems.org' }
   let(:port)        { 443 }
 
   def create_site(scheme, host, port)
-    Puppet::Network::HTTP::Site.new(scheme, host, port)
+    described_class.new(scheme, host, port)
   end
 
   it 'accepts scheme, host, and port' do

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