puppet 6.16.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/face/node_spec.rb

@@ -74,9 +74,9 @@ describe Puppet::Face[:node, '0.0.1'] do
           subject.clean('hostname')
         end
 
-        it "should run in master mode" do
+        it "should run in server mode" do
           subject.clean('hostname')
-          expect(Puppet.run_mode).to be_master
+          expect(Puppet.run_mode).to be_server
         end
 
         it "should set node cache as yaml" do

data/spec/unit/face/plugin_spec.rb

@@ -16,48 +16,88 @@ describe Puppet::Face[:plugin, :current] do
       end
     end
 
-    it "downloads plugins, external facts, and locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+    context "when i18n is enabled" do
+      before(:each) do
+        Puppet[:disable_i18n] = false
+      end
 
-      pluginface.download
-      expect(receive_count).to eq(3)
-    end
+      it "downloads plugins, external facts, and locales" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
-    it "renders 'No plugins downloaded' if nothing was downloaded" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+        pluginface.download
+        expect(receive_count).to eq(3)
+      end
 
-      result = pluginface.download
-      expect(receive_count).to eq(3)
-      expect(render(result)).to eq('No plugins downloaded.')
-    end
+      it "renders 'No plugins downloaded' if nothing was downloaded" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
-    it "renders comma separate list of downloaded file names" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        receive_count += 1
-        case receive_count
-        when 1
-          %w[/a]
-        when 2
-          %w[/b]
-        when 3
-          %w[/c]
-        end
+        result = pluginface.download
+        expect(receive_count).to eq(3)
+        expect(render(result)).to eq('No plugins downloaded.')
       end
 
-      result = pluginface.download
-      expect(receive_count).to eq(3)
-      expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
+      it "renders comma separate list of downloaded file names" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+          receive_count += 1
+          case receive_count
+          when 1
+            %w[/a]
+          when 2
+            %w[/b]
+          when 3
+            %w[/c]
+          end
+        end
+
+        result = pluginface.download
+        expect(receive_count).to eq(3)
+        expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
+      end
     end
 
-    it "uses persistent HTTP pool" do
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        expect(Puppet.lookup(:http_pool)).to be_instance_of(Puppet::Network::HTTP::Pool)
-      end.and_return([])
+    context "when i18n is enabled" do
+      before(:each) do
+        Puppet[:disable_i18n] = true
+      end
 
-      pluginface.download
+      it "downloads only plugins and external facts, no locales" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+
+        pluginface.download
+        expect(receive_count).to eq(2)
+      end
+
+      it "renders 'No plugins downloaded' if nothing was downloaded, without checking for locales" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+
+        result = pluginface.download
+        expect(receive_count).to eq(2)
+        expect(render(result)).to eq('No plugins downloaded.')
+      end
+
+      it "renders comma separate list of downloaded file names" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+          receive_count += 1
+          case receive_count
+          when 1
+            %w[/a]
+          when 2
+            %w[/b]
+          when 3
+            %w[/c]
+          end
+        end
+
+        result = pluginface.download
+        expect(receive_count).to eq(2)
+        expect(render(result)).to eq('Downloaded these plugins: /a, /b')
+      end
     end
   end
 

data/spec/unit/file_bucket/file_spec.rb

@@ -26,7 +26,7 @@ describe Puppet::FileBucket::File, :uses_checksums => true do
   end
 
   it "should require contents to be a string" do
-    expect { Puppet::FileBucket::File.new(5) }.to raise_error(ArgumentError, /contents must be a String or Pathname, got a (?:Fixnum|Integer)$/)
+    expect { Puppet::FileBucket::File.new(5) }.to raise_error(ArgumentError, /contents must be a String or Pathname, got a Integer$/)
   end
 
   it "should complain about options other than :bucket_path" do

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -49,7 +49,7 @@ describe Puppet::FileServing::Configuration::Parser do
       expect { @parser.parse }.to raise_error(ArgumentError)
     end
 
-    it "should fail if the value for path/allow/deny starts with an equals sign" do
+    it "should fail if the value for path starts with an equals sign" do
       write_config_file "[one]\npath = /testing"
       expect { @parser.parse }.to raise_error(ArgumentError)
     end
@@ -98,32 +98,28 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     [:allow,:deny].each { |acl_type|
-      it "should support inline comments in #{acl_type}" do
+      it "should ignore inline comments in #{acl_type}" do
         write_config_file "[one]\n#{acl_type} something \# will it work?\n"
 
-      expect(@mount).to receive(:info)
-      expect(@mount).to receive(acl_type).with("something")
-      @parser.parse
+        expect(@parser.parse).to eq('one' => @mount)
       end
 
-      it "should tell the mount to #{acl_type} from ACLs with varying spacing around commas" do
+      it "should ignore #{acl_type} from ACLs with varying spacing around commas" do
         write_config_file "[one]\n#{acl_type} someone,sometwo, somethree , somefour ,somefive\n"
 
-        expect(@mount).to receive(:info).exactly(5).times
-        expect(@mount).to receive(acl_type).exactly(5).times.with(eq('someone').or eq('sometwo').or eq('somethree').or eq('somefour').or eq('somefive'))
-        @parser.parse
+        expect(@parser.parse).to eq('one' => @mount)
       end
 
-      # each ip, with glob in the various octet positions
-      ['100','4','42','*'].permutation.map {|permutes| permutes.join('.') }.each { |ip_pattern|
-        it "should tell the mount to #{acl_type} from ACLs with glob at #{ip_pattern}" do
-          write_config_file "[one]\n#{acl_type} #{ip_pattern}\n"
+      it "should log an error and print the location of the #{acl_type} rule" do
+        write_config_file(<<~CONFIG)
+        [one]
+        #{acl_type} one
+        CONFIG
+
+        expect(Puppet).to receive(:err).with(/Entry '#{acl_type} one' is unsupported and will be ignored at \(file: .*, line: 2\)/)
 
-          expect(@mount).to receive(:info)
-          expect(@mount).to receive(acl_type).with(ip_pattern)
-          @parser.parse
-        end
-      }
+        @parser.parse
+      end
     }
 
     it "should return comprehensible error message, if failed on invalid attribute" do

data/spec/unit/file_serving/configuration_spec.rb

@@ -90,17 +90,14 @@ describe Puppet::FileServing::Configuration do
 
     it "should allow all access to modules, plugins, and tasks if no fileserver.conf exists" do
       expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
-      modules = double('modules', :empty? => true)
+      modules = double('modules')
       allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      expect(modules).to receive(:allow).with('*')
 
-      plugins = double('plugins', :empty? => true)
+      plugins = double('plugins')
       allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      expect(plugins).to receive(:allow).with('*')
 
-      tasks = double('tasks', :empty? => true)
+      tasks = double('tasks')
       allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      expect(tasks).to receive(:allow).with('*')
 
       Puppet::FileServing::Configuration.configuration
     end
@@ -108,17 +105,14 @@ describe Puppet::FileServing::Configuration do
     it "should not allow access from all to modules, plugins, and tasks if the fileserver.conf provided some rules" do
       expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
 
-      modules = double('modules', :empty? => false)
+      modules = double('modules')
       allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      expect(modules).not_to receive(:allow).with('*')
 
-      plugins = double('plugins', :empty? => false)
+      plugins = double('plugins')
       allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      expect(plugins).not_to receive(:allow).with('*')
 
-      tasks = double('tasks', :empty? => false)
+      tasks = double('tasks')
       allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      expect(tasks).not_to receive(:allow).with('*')
 
       Puppet::FileServing::Configuration.configuration
     end

data/spec/unit/file_serving/http_metadata_spec.rb

@@ -30,11 +30,6 @@ describe Puppet::FileServing::HttpMetadata do
     end
 
     context "with no Last-Modified or Content-MD5 header from the server" do
-      before do
-        allow(http_response).to receive(:[]).with('last-modified').and_return(nil)
-        allow(http_response).to receive(:[]).with('content-md5').and_return(nil)
-      end
-
       it "should use :mtime as the checksum type, based on current time" do
         # Stringifying Time.now does some rounding; do so here so we don't end up with a time
         # that's greater than the stringified version returned by collect.
@@ -51,13 +46,9 @@ describe Puppet::FileServing::HttpMetadata do
     context "with a Last-Modified header from the server" do
       let(:time) { Time.now.utc }
 
-      before do
-        allow(http_response).to receive(:[]).with('content-md5').and_return(nil)
-      end
-
       it "should use :mtime as the checksum type, based on Last-Modified" do
         # HTTP uses "GMT" not "UTC"
-        allow(http_response).to receive(:[]).with('last-modified').and_return(time.strftime("%a, %d %b %Y %T GMT"))
+        http_response.add_field('last-modified', time.strftime("%a, %d %b %Y %T GMT"))
         metadata = described_class.new(http_response)
         metadata.collect
         expect( metadata.checksum_type ).to eq :mtime
@@ -70,16 +61,48 @@ describe Puppet::FileServing::HttpMetadata do
       let(:base64) { Digest::MD5.new.base64digest input }
       let(:hex) { Digest::MD5.new.hexdigest input }
 
-      before do
-        allow(http_response).to receive(:[]).with('last-modified').and_return(nil)
-        allow(http_response).to receive(:[]).with('content-md5').and_return(base64)
+      it "should use the md5 checksum" do
+        http_response.add_field('content-md5', base64)
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :md5
+        expect( metadata.checksum ).to eq "{md5}#{hex}"
       end
+    end
+
+    context "with X-Checksum-Md5" do
+      let(:md5) { "c58989e9740a748de4f5054286faf99b" }
 
       it "should use the md5 checksum" do
+        http_response.add_field('X-Checksum-Md5', md5)
         metadata = described_class.new(http_response)
         metadata.collect
         expect( metadata.checksum_type ).to eq :md5
-        expect( metadata.checksum ).to eq "{md5}#{hex}"
+        expect( metadata.checksum ).to eq "{md5}#{md5}"
+      end
+    end
+
+    context "with X-Checksum-Sha1" do
+      let(:sha1) { "01e4d15746f4274b84d740a93e04b9fd2882e3ea" }
+
+      it "should use the SHA1 checksum" do
+        http_response.add_field('X-Checksum-Sha1', sha1)
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :sha1
+        expect( metadata.checksum ).to eq "{sha1}#{sha1}"
+      end
+    end
+
+    context "with X-Checksum-Sha256" do
+      let(:sha256) { "a3eda98259c30e1e75039c2123670c18105e1c46efb672e42ca0e4cbe77b002a" }
+
+      it "should use the SHA256 checksum" do
+        http_response.add_field('X-Checksum-Sha256', sha256)
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :sha256
+        expect( metadata.checksum ).to eq "{sha256}#{sha256}"
       end
     end
   end

data/spec/unit/file_serving/mount/locales_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::Locales do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have locales and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have locales and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:locales?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the locale paths for each module that has locales" do

data/spec/unit/file_serving/mount/pluginfacts_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::PluginFacts do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have plugins and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:pluginfacts?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the plugin paths for each module that has plugins" do

data/spec/unit/file_serving/mount/plugins_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::Plugins do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have plugins and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:plugins?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the plugin paths for each module that has plugins" do

data/spec/unit/file_serving/terminus_selector_spec.rb

@@ -3,62 +3,81 @@ require 'spec_helper'
 require 'puppet/file_serving/terminus_selector'
 
 describe Puppet::FileServing::TerminusSelector do
-  before do
-    @object = Object.new
-    @object.extend(Puppet::FileServing::TerminusSelector)
+  class TestSelector
+    include Puppet::FileServing::TerminusSelector
+  end
 
-    @request = double('request', :key => "mymod/myfile", :options => {:node => "whatever"}, :server => nil, :protocol => nil)
+  def create_request(key)
+    Puppet::Indirector::Request.new(:indirection_name, :find, key, nil, {node: 'whatever'})
   end
 
+  subject { TestSelector.new }
+
   describe "when being used to select termini" do
     it "should return :file if the request key is fully qualified" do
-      expect(@request).to receive(:key).and_return(File.expand_path('/foo'))
-      expect(@object.select(@request)).to eq(:file)
+      request = create_request(File.expand_path('/foo'))
+
+      expect(subject.select(request)).to eq(:file)
+    end
+
+    it "should return :file_server if the request key is relative" do
+      request = create_request('modules/my_module/path/to_file')
+
+      expect(subject.select(request)).to eq(:file_server)
     end
 
     it "should return :file if the URI protocol is set to 'file'" do
-      expect(@request).to receive(:protocol).and_return("file")
-      expect(@object.select(@request)).to eq(:file)
+      request = create_request(Puppet::Util.path_to_uri(File.expand_path("/foo")).to_s)
+
+      expect(subject.select(request)).to eq(:file)
     end
 
     it "should return :http if the URI protocol is set to 'http'" do
-      expect(@request).to receive(:protocol).and_return("http")
-      expect(@object.select(@request)).to eq :http
+      request = create_request("http://www.example.com")
+
+      expect(subject.select(request)).to eq(:http)
     end
 
     it "should return :http if the URI protocol is set to 'https'" do
-      expect(@request).to receive(:protocol).and_return("https")
-      expect(@object.select(@request)).to eq :http
+      request = create_request("https://www.example.com")
+
+      expect(subject.select(request)).to eq(:http)
+    end
+
+    it "should return :http if the path starts with a double slash" do
+      request = create_request("https://www.example.com//index.html")
+
+      expect(subject.select(request)).to eq(:http)
     end
 
     it "should fail when a protocol other than :puppet, :http(s) or :file is used" do
-      allow(@request).to receive(:protocol).and_return("ftp")
-      expect { @object.select(@request) }.to raise_error(ArgumentError)
+      request = create_request("ftp://ftp.example.com")
+
+      expect {
+        subject.select(request)
+      }.to raise_error(ArgumentError, /URI protocol 'ftp' is not currently supported for file serving/)
     end
 
     describe "and the protocol is 'puppet'" do
-      before do
-        allow(@request).to receive(:protocol).and_return("puppet")
-      end
-
       it "should choose :rest when a server is specified" do
-        allow(@request).to receive(:protocol).and_return("puppet")
-        expect(@request).to receive(:server).and_return("foo")
-        expect(@object.select(@request)).to eq(:rest)
+        request = create_request("puppet://puppetserver.example.com")
+
+        expect(subject.select(request)).to eq(:rest)
       end
 
       # This is so a given file location works when bootstrapping with no server.
       it "should choose :rest when default_file_terminus is rest" do
-        allow(@request).to receive(:protocol).and_return("puppet")
         Puppet[:server] = 'localhost'
-        expect(@object.select(@request)).to eq(:rest)
+        request = create_request("puppet:///plugins")
+
+        expect(subject.select(request)).to eq(:rest)
       end
 
       it "should choose :file_server when default_file_terminus is file_server and no server is specified on the request" do
-        expect(@request).to receive(:protocol).and_return("puppet")
-        expect(@request).to receive(:server).and_return(nil)
         Puppet[:default_file_terminus] = 'file_server'
-        expect(@object.select(@request)).to eq(:file_server)
+        request = create_request("puppet:///plugins")
+
+        expect(subject.select(request)).to eq(:file_server)
       end
     end
   end