puppet 6.14.0-universal-darwin → 6.19.0-universal-darwin

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

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+require 'puppet/indirector/file_metadata'
+require 'puppet/indirector/file_metadata/http'
+
+describe Puppet::Indirector::FileMetadata::Http do
+  DEFAULT_HEADERS = {
+    "Cache-Control" => "private, max-age=0",
+    "Connection" => "close",
+    "Content-Encoding" => "gzip",
+    "Content-Type" => "text/html; charset=ISO-8859-1",
+    "Date" => "Fri, 01 May 2020 17:16:00 GMT",
+    "Expires" => "-1",
+    "Server" => "gws"
+  }.freeze
+
+  let(:certname) { 'ziggy' }
+  # The model is Puppet:FileServing::Metadata
+  let(:model) { described_class.model }
+  # The http terminus creates instances of HttpMetadata which subclass Metadata
+  let(:metadata) { Puppet::FileServing::HttpMetadata.new(key) }
+  let(:key) { "https://example.com/path/to/file" }
+  # Digest::MD5.base64digest("") => "1B2M2Y8AsgTpgAmY7PhCfg=="
+  let(:content_md5) { {"Content-MD5" => "1B2M2Y8AsgTpgAmY7PhCfg=="} }
+  let(:last_modified) { {"Last-Modified" => "Wed, 01 Jan 2020 08:00:00 GMT"} }
+
+  before :each do
+    described_class.indirection.terminus_class = :http
+  end
+
+  context "when finding" do
+    it "returns http file metadata" do
+      stub_request(:head, key)
+        .to_return(status: 200, headers: DEFAULT_HEADERS)
+
+      result = model.indirection.find(key)
+      expect(result.ftype).to eq('file')
+      expect(result.path).to eq('/dev/null')
+      expect(result.relative_path).to be_nil
+      expect(result.destination).to be_nil
+      expect(result.checksum).to match(%r{mtime})
+      expect(result.owner).to be_nil
+      expect(result.group).to be_nil
+      expect(result.mode).to be_nil
+    end
+
+    it "reports an md5 checksum if present in the response" do
+      stub_request(:head, key)
+        .to_return(status: 200, headers: DEFAULT_HEADERS.merge(content_md5))
+
+      result = model.indirection.find(key)
+      expect(result.checksum_type).to eq(:md5)
+      expect(result.checksum).to eq("{md5}d41d8cd98f00b204e9800998ecf8427e")
+    end
+
+    it "reports an mtime checksum if present in the response" do
+      stub_request(:head, key)
+        .to_return(status: 200, headers: DEFAULT_HEADERS.merge(last_modified))
+
+      result = model.indirection.find(key)
+      expect(result.checksum_type).to eq(:mtime)
+      expect(result.checksum).to eq("{mtime}2020-01-01 08:00:00 UTC")
+    end
+
+    it "prefers md5" do
+      stub_request(:head, key)
+        .to_return(status: 200, headers: DEFAULT_HEADERS.merge(content_md5).merge(last_modified))
+
+      result = model.indirection.find(key)
+      expect(result.checksum_type).to eq(:md5)
+      expect(result.checksum).to eq("{md5}d41d8cd98f00b204e9800998ecf8427e")
+    end
+
+    it "prefers mtime when explicitly requested" do
+      stub_request(:head, key)
+        .to_return(status: 200, headers: DEFAULT_HEADERS.merge(content_md5).merge(last_modified))
+
+      result = model.indirection.find(key, checksum_type: :mtime)
+      expect(result.checksum_type).to eq(:mtime)
+      expect(result.checksum).to eq("{mtime}2020-01-01 08:00:00 UTC")
+    end
+
+    it "leniently parses base64" do
+      # Content-MD5 header is missing '==' padding
+      stub_request(:head, key)
+        .to_return(status: 200, headers: DEFAULT_HEADERS.merge("Content-MD5" => "1B2M2Y8AsgTpgAmY7PhCfg"))
+
+      result = model.indirection.find(key)
+      expect(result.checksum_type).to eq(:md5)
+      expect(result.checksum).to eq("{md5}d41d8cd98f00b204e9800998ecf8427e")
+    end
+
+    it "URL encodes special characters" do
+      pending("HTTP terminus doesn't encode the URI before parsing")
+
+      stub_request(:head, %r{/path%20to%20file})
+
+      model.indirection.find('https://example.com/path to file')
+    end
+
+    it "sends query parameters" do
+      stub_request(:head, key).with(query: {'a' => 'b'})
+
+      model.indirection.find("#{key}?a=b")
+    end
+
+    it "returns nil if the content doesn't exist" do
+      stub_request(:head, key).to_return(status: 404)
+
+      expect(model.indirection.find(key)).to be_nil
+    end
+
+    it "returns nil if fail_on_404" do
+      stub_request(:head, key).to_return(status: 404)
+
+      expect(model.indirection.find(key, fail_on_404: true)).to be_nil
+    end
+
+    it "returns nil on HTTP 500" do
+      stub_request(:head, key).to_return(status: 500)
+
+      # this is kind of strange, but it does allow puppet to try
+      # multiple `source => ["URL1", "URL2"]` and use the first
+      # one based on sourceselect
+      expect(model.indirection.find(key)).to be_nil
+    end
+
+    it "accepts all content types" do
+      stub_request(:head, key).with(headers: {'Accept' => '*/*'})
+
+      model.indirection.find(key)
+    end
+
+    it "sets puppet user-agent" do
+      stub_request(:head, key).with(headers: {'User-Agent' => Puppet[:http_user_agent]})
+
+      model.indirection.find(key)
+    end
+
+    it "tries to persist the connection" do
+      # HTTP/1.1 defaults to persistent connections, so check for
+      # the header's absence
+      stub_request(:head, key).with do |request|
+        expect(request.headers).to_not include('Connection')
+      end
+
+      model.indirection.find(key)
+    end
+
+    it "follows redirects" do
+      new_url = "https://example.com/different/path"
+      redirect = { status: 200, headers: { 'Location' => new_url }, body: ""}
+      stub_request(:head, key).to_return(redirect)
+      stub_request(:head, new_url)
+
+      model.indirection.find(key)
+    end
+
+    it "falls back to partial GET if HEAD is not allowed" do
+      stub_request(:head, key)
+        .to_return(status: 405)
+      stub_request(:get, key)
+        .to_return(status: 200, headers: {'Range' => 'bytes=0-0'})
+
+      model.indirection.find(key)
+    end
+
+    it "falls back to partial GET if HEAD is forbidden" do
+      stub_request(:head, key)
+        .to_return(status: 403)
+      stub_request(:get, key)
+        .to_return(status: 200, headers: {'Range' => 'bytes=0-0'})
+
+      model.indirection.find(key)
+    end
+
+    it "returns nil if the partial GET fails" do
+      stub_request(:head, key)
+        .to_return(status: 403)
+      stub_request(:get, key)
+        .to_return(status: 403)
+
+      expect(model.indirection.find(key)).to be_nil
+    end
+  end
+
+  context "when searching" do
+    it "raises an error" do
+      expect {
+        model.indirection.search(key)
+      }.to raise_error(Puppet::Error, 'cannot lookup multiple files')
+    end
+  end
+end

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