puppet 6.15.0-universal-darwin → 6.19.1-universal-darwin

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

@@ -6,6 +6,7 @@ require 'puppet/indirector/file_metadata/rest'
 describe Puppet::Indirector::FileMetadata::Rest do
   let(:certname) { 'ziggy' }
   let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+  let(:model) { described_class.model }
 
   before :each do
     described_class.indirection.terminus_class = :rest
@@ -18,13 +19,13 @@ describe Puppet::Indirector::FileMetadata::Rest do
   context "when finding" do
     let(:uri) { %r{/puppet/v3/file_metadata/:mount/path/to/file} }
     let(:key) { "puppet:///:mount/path/to/file" }
-    let(:metadata) { Puppet::FileServing::Metadata.new('/path/to/file') }
+    let(:metadata) { model.new('/path/to/file') }
 
     it "returns file metadata" do
       stub_request(:get, uri)
         .to_return(status: 200, **metadata_response(metadata))
 
-      result = described_class.indirection.find(key)
+      result = model.indirection.find(key)
       expect(result.path).to eq('/path/to/file')
     end
 
@@ -32,20 +33,20 @@ describe Puppet::Indirector::FileMetadata::Rest do
       stub_request(:get, %r{/puppet/v3/file_metadata/:mount/path%20to%20file})
         .to_return(status: 200, **metadata_response(metadata))
 
-      described_class.indirection.find('puppet:///:mount/path to file')
+      model.indirection.find('puppet:///:mount/path to file')
     end
 
     it "returns nil if the content doesn't exist" do
       stub_request(:get, uri).to_return(status: 404)
 
-      expect(described_class.indirection.find(key)).to be_nil
+      expect(model.indirection.find(key)).to be_nil
     end
 
     it "raises if fail_on_404 is true" do
       stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json'}, body: "{}")
 
       expect {
-        described_class.indirection.find(key, fail_on_404: true)
+        model.indirection.find(key, fail_on_404: true)
       }.to raise_error(Puppet::Error, %r{Find /puppet/v3/file_metadata/:mount/path/to/file resulted in 404 with the message: {}})
     end
 
@@ -53,7 +54,7 @@ describe Puppet::Indirector::FileMetadata::Rest do
       stub_request(:get, uri).to_return(status: 500, headers: { 'Content-Type' => 'application/json'}, body: "{}")
 
       expect {
-        described_class.indirection.find(key)
+        model.indirection.find(key)
       }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
     end
 
@@ -61,20 +62,20 @@ describe Puppet::Indirector::FileMetadata::Rest do
       stub_request(:get, %r{https://example.com:8140/puppet/v3/file_metadata/:mount/path/to/file})
         .to_return(status: 200, **metadata_response(metadata))
 
-      described_class.indirection.find("puppet://example.com:8140/:mount/path/to/file")
+      model.indirection.find("puppet://example.com:8140/:mount/path/to/file")
     end
   end
 
   context "when searching" do
     let(:uri) { %r{/puppet/v3/file_metadatas/:mount/path/to/dir} }
     let(:key) { "puppet:///:mount/path/to/dir" }
-    let(:metadatas) { [Puppet::FileServing::Metadata.new('/path/to/dir')] }
+    let(:metadatas) { [model.new('/path/to/dir')] }
 
     it "returns an array of file metadata" do
       stub_request(:get, uri)
         .to_return(status: 200, **metadata_response(metadatas))
 
-      result = described_class.indirection.search(key)
+      result = model.indirection.search(key)
       expect(result.first.path).to eq('/path/to/dir')
     end
 
@@ -82,26 +83,26 @@ describe Puppet::Indirector::FileMetadata::Rest do
       stub_request(:get, %r{/puppet/v3/file_metadatas/:mount/path%20to%20dir})
         .to_return(status: 200, **metadata_response(metadatas))
 
-      described_class.indirection.search('puppet:///:mount/path to dir')
+      model.indirection.search('puppet:///:mount/path to dir')
     end
 
     it "returns an empty array if the metadata doesn't exist" do
       stub_request(:get, uri).to_return(status: 404)
 
-      expect(described_class.indirection.search(key)).to eq([])
+      expect(model.indirection.search(key)).to eq([])
     end
 
     it "returns an empty array if the metadata doesn't exist and fail_on_404 is true" do
       stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json'}, body: "{}")
 
-      expect(described_class.indirection.search(key, fail_on_404: true)).to eq([])
+      expect(model.indirection.search(key, fail_on_404: true)).to eq([])
     end
 
     it "raises an error on HTTP 500" do
       stub_request(:get, uri).to_return(status: 500, headers: { 'Content-Type' => 'application/json'}, body: "{}")
 
       expect {
-        described_class.indirection.search(key)
+        model.indirection.search(key)
       }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
     end
 
@@ -109,7 +110,7 @@ describe Puppet::Indirector::FileMetadata::Rest do
       stub_request(:get, %r{https://example.com:8140/puppet/v3/file_metadatas/:mount/path/to/dir})
         .to_return(status: 200, **metadata_response(metadatas))
 
-      described_class.indirection.search("puppet://example.com:8140/:mount/path/to/dir")
+      model.indirection.search("puppet://example.com:8140/:mount/path/to/dir")
     end
   end
 

data/spec/unit/indirector/json_spec.rb

@@ -11,24 +11,24 @@ describe Puppet::Indirector::JSON do
 
   context "#path" do
     before :each do
-      Puppet[:server_datadir] = '/sample/datadir/master'
+      Puppet[:server_datadir] = '/sample/datadir/server'
       Puppet[:client_datadir] = '/sample/datadir/client'
     end
 
-    it "uses the :server_datadir setting if this is the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+    it "uses the :server_datadir setting if this is the server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.json')
       expect(subject.path('testing')).to eq(expected)
     end
 
-    it "uses the :client_datadir setting if this is not the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    it "uses the :client_datadir setting if this is not the server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.json')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-json')
       expect(subject.path('testing', '.not-json')).to eq(expected)
     end
@@ -50,7 +50,7 @@ describe Puppet::Indirector::JSON do
 
   context "handling requests" do
     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'))
     end
@@ -158,7 +158,7 @@ describe Puppet::Indirector::JSON do
 
   context "#search" do
     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'))
     end

data/spec/unit/indirector/msgpack_spec.rb

@@ -11,24 +11,24 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
   context "#path" do
     before :each do
-      Puppet[:server_datadir] = '/sample/datadir/master'
+      Puppet[:server_datadir] = '/sample/datadir/server'
       Puppet[:client_datadir] = '/sample/datadir/client'
     end
 
-    it "uses the :server_datadir setting if this is the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+    it "uses the :server_datadir setting if this is the server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.msgpack')
       expect(subject.path('testing')).to eq(expected)
     end
 
-    it "uses the :client_datadir setting if this is not the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    it "uses the :client_datadir setting if this is not the server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.msgpack')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-msgpack')
       expect(subject.path('testing', '.not-msgpack')).to eq(expected)
     end
@@ -50,7 +50,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
   context "handling requests" do
     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('msgpackdir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end
@@ -158,7 +158,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
   context "#search" do
     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('msgpackdir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end

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

@@ -10,7 +10,7 @@ describe Puppet::Node::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/request_spec.rb

@@ -94,7 +94,7 @@ describe Puppet::Indirector::Request do
 
       describe "and the URI is a 'file' URI" do
         before do
-          @request = Puppet::Indirector::Request.new(:ind, :method, "#{URI.unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
+          @request = Puppet::Indirector::Request.new(:ind, :method, "#{Puppet::Util.uri_unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
         end
 
         it "should set the request key to the unescaped full file path" do
@@ -126,8 +126,8 @@ describe Puppet::Indirector::Request do
         expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/", nil).port).to eq(543)
       end
 
-      it "should default to the masterport if the URI scheme is 'puppet'" do
-        Puppet[:masterport] = "321"
+      it "should default to the serverport if the URI scheme is 'puppet'" do
+        Puppet[:serverport] = "321"
         expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/", nil).port).to eq(321)
       end
 
@@ -534,7 +534,7 @@ describe Puppet::Indirector::Request do
           expect(request.server).to be_nil
           expect(request.port).to be_nil
           expect(Puppet.settings[:server]).not_to be_nil
-          expect(Puppet.settings[:masterport]).not_to be_nil
+          expect(Puppet.settings[:serverport]).not_to be_nil
         end
       end
     end
@@ -552,7 +552,7 @@ describe Puppet::Indirector::Request do
       req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
       req.do_request() do |request|
         expect(request.server).to eq(Puppet.settings[:server])
-        expect(request.port).to eq(Puppet.settings[:masterport])
+        expect(request.port).to eq(Puppet.settings[:serverport])
       end
     end
   end

data/spec/unit/indirector/rest_spec.rb

@@ -45,6 +45,19 @@ shared_examples_for "a REST terminus method" do |terminus_method|
 
       expect(Puppet[:preferred_serialization_format]).to eq("pson")
     end
+
+    it "logs a deprecation warning" do
+      terminus.send(terminus_method, request)
+
+      expect(@logs).to include(an_object_having_attributes(level: :warning, message: /Puppet::Indirector::Rest##{terminus_method} is deprecated. Use Puppet::HTTP::Client instead./))
+    end
+
+    it "omits the warning when deprecations are disabled" do
+      Puppet[:disable_warnings] = 'deprecations'
+      terminus.send(terminus_method, request)
+
+      expect(@logs).to eq([])
+    end
   end
 
   HTTP_ERROR_CODES.each do |code|
@@ -236,7 +249,7 @@ describe Puppet::Indirector::REST do
 
   it "should default to :port for the port setting" do
     expect(terminus_class).to receive(:port_setting).and_return(nil)
-    Puppet[:masterport] = "543"
+    Puppet[:serverport] = "543"
     expect(terminus_class.port).to eq(543)
   end
 

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

@@ -9,7 +9,7 @@ describe Puppet::Indirector::Status::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/yaml_spec.rb

@@ -38,30 +38,30 @@ describe Puppet::Indirector::Yaml do
 
   before :each do
     Puppet[:clientyamldir] = dir
-    allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    allow(Puppet.run_mode).to receive(:server?).and_return(false)
   end
 
   describe "when choosing file location" do
-    it "should use the server_datadir if the run_mode is master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+    it "should use the server_datadir if the run_mode is server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me)).to match(/^#{serverdir}/)
     end
 
-    it "should use the client yamldir if the run_mode is not master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    it "should use the client yamldir if the run_mode is not server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(false)
       Puppet[:clientyamldir] = clientdir
       expect(terminus.path(:me)).to match(/^#{clientdir}/)
     end
 
     it "should use the extension if one is specified" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me,'.farfignewton')).to match(%r{\.farfignewton$})
     end
 
     it "should assume an extension of .yaml if none is specified" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me)).to match(%r{\.yaml$})
     end

data/spec/unit/interface_spec.rb

@@ -180,7 +180,7 @@ describe Puppet::Interface do
           display_global_options "modulepath"
         end
       end
-      face.display_global_options =~ ["environment"]
+      expect(face.display_global_options).to match(["environment"])
     end
 
     it "should not fail when a face d_g_o duplicates an action d_g_o" do
@@ -200,8 +200,8 @@ describe Puppet::Interface do
         action :foo do when_invoked {|_| true} ; display_global_options "environment" end
         action :bar do when_invoked {|_| true} ; display_global_options "environment" end
       end
-      face.get_action(:foo).display_global_options =~ ["environment"]
-      face.get_action(:bar).display_global_options =~ ["environment"]
+      expect(face.get_action(:foo).display_global_options).to match(["environment"])
+      expect(face.get_action(:bar).display_global_options).to match(["environment"])
     end
       
   end

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -86,4 +86,24 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
         and_yield(type, name, {:entry => entry})
     entry
   end
+
+  describe "Extracts tars with long and short pathnames" do
+    let (:sourcetar) { fixtures('module.tar.gz') }
+    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
+    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
+
+    it "unpacks a tar with a short path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
+    end
+
+    it "unpacks a tar with a long path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
+    end
+  end
 end

data/spec/unit/network/format_support_spec.rb

@@ -67,8 +67,9 @@ describe Puppet::Network::FormatHandler do
       end
 
       it "should log a debug message" do
-        expect(Puppet).to receive(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
-        expect(Puppet).to receive(:debug).with("FormatTester supports formats: two one")
+        Puppet[:log_level] = 'debug'
+        expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)") }
+        expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("FormatTester supports formats: two one") }
         FormatTester.supported_formats
       end
     end

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -344,7 +344,8 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
       expect {
         handler.call(request, response)
-      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError, /No supported formats are acceptable/)
+      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError,
+                       %r{No supported formats are acceptable \(Accept: application/json, text/pson\)})
     end
 
     it "should return [] when searching returns an empty array" do

data/spec/unit/network/http/api/master/v3/environments_spec.rb

@@ -7,13 +7,14 @@ require 'matchers/json'
 describe Puppet::Network::HTTP::API::Master::V3::Environments do
   include JSONMatchers
 
-  it "responds with all of the available environments" do
-    environment = Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests')
-    loader = Puppet::Environments::Static.new(environment)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+  let(:environment) { Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests') }
+  let(:loader) { Puppet::Environments::Static.new(environment) }
+  let(:handler) { Puppet::Network::HTTP::API::Master::V3::Environments.new(loader) }
+  let(:request) { Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }) }
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+  it "responds with all of the available environments" do
+    handler.call(request, response)
 
     expect(response.code).to eq(200)
     expect(response.type).to eq("application/json")
@@ -33,29 +34,17 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for unlimited timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(Float::INFINITY)
-    environment = Puppet::Node::Environment.create(:production, [])
-    env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+    Puppet[:environment_timeout] = 'unlimited'
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
 
   it "the response conforms to the environments schema for integer timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(1)
-    environment = Puppet::Node::Environment.create(:production, [])
-    env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
-
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    Puppet[:environment_timeout] = 1
+
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end