puppet 6.24.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/face/node_spec.rb

@@ -15,6 +15,13 @@ describe Puppet::Face[:node, '0.0.1'] do
   end
 
   describe 'when running #clean' do
+    before :each do
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
+      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
+      allow(Puppet::Node).to receive(:terminus_class=)
+      allow(Puppet::Node).to receive(:cache_class=)
+    end
+
     it 'should invoke #cleanup' do
       expect(subject).to receive(:cleanup).with('hostname')
       subject.clean('hostname')
@@ -23,6 +30,10 @@ describe Puppet::Face[:node, '0.0.1'] do
 
   describe "clean action" do
     before :each do
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
+      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
+      allow(Puppet::Node).to receive(:terminus_class=)
+      allow(Puppet::Node).to receive(:cache_class=)
       allow(subject).to receive(:cleanup)
     end
 

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
@@ -87,6 +87,7 @@ describe Puppet::FileServing::Configuration::Parser do
     before do
       @mount = double('testmount', :name => "one", :validate => true)
       expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(@mount)
+      allow(@parser).to receive(:add_modules_mount)
     end
 
     it "should set the mount path to the path attribute from that section" do
@@ -97,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/fileset_spec.rb

@@ -46,13 +46,6 @@ describe Puppet::FileServing::Fileset do
       expect(set.recurselimit).to eq(3)
     end
 
-    it "accepts a 'max_files' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
-      set = Puppet::FileServing::Fileset.new(somefile, :recurselimit => 3, :max_files => 100)
-      expect(set.recurselimit).to eq(3)
-      expect(set.max_files).to eq(100)
-    end
-
     it "accepts an 'ignore' option" do
       expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
       set = Puppet::FileServing::Fileset.new(somefile, :ignore => ".svn")
@@ -167,29 +160,6 @@ describe Puppet::FileServing::Fileset do
       end
     end
 
-    def mock_big_dir_structure(path, stat_method = :lstat)
-      allow(Puppet::FileSystem).to receive(stat_method).with(path).and_return(@dirstat)
-
-      # Keep track of the files we're stubbing.
-      @files = %w{.}
-
-      top_names = (1..10).map {|i| "dir_#{i}" }
-      sub_names = (1..100).map {|i| "file__#{i}" }
-
-      allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(top_names)
-      top_names.each do |subdir|
-        @files << subdir # relative path
-        subpath = File.join(path, subdir)
-        allow(Puppet::FileSystem).to receive(stat_method).with(subpath).and_return(@dirstat)
-        allow(Dir).to receive(:entries).with(subpath, encoding: Encoding::UTF_8).and_return(sub_names)
-        sub_names.each do |file|
-          @files << File.join(subdir, file) # relative path
-          subfile_path = File.join(subpath, file)
-          allow(Puppet::FileSystem).to receive(stat_method).with(subfile_path).and_return(@filestat)
-        end
-      end
-    end
-
     def setup_mocks_for_dir(mock_dir, base_path)
       path = File.join(base_path, mock_dir.name)
       allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(MockStat.new(path, true))
@@ -288,36 +258,6 @@ describe Puppet::FileServing::Fileset do
       expect(@fileset.files.find { |file| file.include?("0") }).to be_nil
     end
 
-    it "raises exception if number of files is greater than :max_files" do
-      mock_dir_structure(@path)
-      @fileset.recurse = true
-      @fileset.max_files = 22
-      expect { @fileset.files }.to raise_error(Puppet::Error, "The directory '#{@path}' contains 28 entries, which exceeds the limit of 22 specified by the max_files parameter for this resource. The limit may be increased, but be aware that large number of file resources can result in excessive resource consumption and degraded performance. Consider using an alternate method to manage large directory trees")
-    end
-
-    it "logs a warning if number of files is greater than soft max_files limit of 1000" do
-      mock_big_dir_structure(@path)
-      @fileset.recurse = true
-      expect(Puppet).to receive(:warning).with("The directory '#{@path}' contains 1010 entries, which exceeds the default soft limit 1000 and may cause excessive resource consumption and degraded performance. To remove this warning set a value for `max_files` parameter or consider using an alternate method to manage large directory trees")
-      expect { @fileset.files }.to_not raise_error
-    end
-
-    it "does not emit a warning if max_files is -1" do
-      mock_big_dir_structure(@path)
-      @fileset.recurse = true
-      @fileset.max_files = -1
-      expect(Puppet).to receive(:warning).never
-      @fileset.files
-    end
-
-    it "does not emit a warning if max_files is `-1`(string)" do
-      mock_big_dir_structure(@path)
-      @fileset.recurse = true
-      @fileset.max_files = '-1'
-      expect(Puppet).to receive(:warning).never
-      @fileset.files
-    end
-
     it "ignores files that match a pattern given as a boolean" do
       mock_dir_structure(@path)
       @fileset.recurse = true

data/spec/unit/file_serving/metadata_spec.rb

@@ -266,9 +266,9 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       path = tmpfile('bar')
       FileUtils.touch(path)
 
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path, :use).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path, :use).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path, :use).and_raise(invalid_error)
 
       stat = Puppet::FileSystem.stat(path)
 

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -2,20 +2,13 @@ require 'spec_helper'
 
 require 'puppet/file_serving/terminus_helper'
 
-class Puppet::FileServing::TestHelper
-  include Puppet::FileServing::TerminusHelper
-
-  attr_reader :model
-
-  def initialize(model)
-    @model = model
-  end
-end
-
 describe Puppet::FileServing::TerminusHelper do
   before do
+    @helper = Object.new
+    @helper.extend(Puppet::FileServing::TerminusHelper)
+
     @model = double('model')
-    @helper = Puppet::FileServing::TestHelper.new(@model)
+    allow(@helper).to receive(:model).and_return(@model)
 
     @request = double('request', :key => "url", :options => {})
 

data/spec/unit/file_system_spec.rb

@@ -290,12 +290,6 @@ describe "Puppet::FileSystem" do
         expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \r\nsecond line \n")
       end
     end
-
-    it "should ignore leading BOM" do
-      with_file_content("\uFEFFfile content \n") do |file|
-        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \n")
-      end
-    end
   end
 
   context "read without an encoding specified" do
@@ -1005,15 +999,6 @@ describe "Puppet::FileSystem" do
             Puppet::FileSystem.replace_file(dest, 0755) { |_| }
           }.to raise_error(ArgumentError, /Only modes 0644, 0640, 0660, and 0440 are allowed/)
         end
-
-        it 'falls back to fully qualified user name when sid retrieval fails' do
-          current_user_sid = Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name)
-          allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with(Puppet::Util::Windows::ADSI::User.current_user_name).and_return(nil, current_user_sid)
-          allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with(Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name).and_call_original
-
-          Puppet::FileSystem.replace_file(dest, 0644) { |f| f.write(content) }
-          expects_public_file(dest)
-        end
       end
     end
 

data/spec/unit/forge/module_release_spec.rb

@@ -22,8 +22,13 @@ describe Puppet::Forge::ModuleRelease do
   let(:uri) { " "}
   let(:release) { Puppet::Forge::ModuleRelease.new(ssl_repository, JSON.parse(release_json)) }
 
-  let(:mock_file) { double('file', path: '/dev/null') }
-  let(:mock_dir) { tmpdir('dir') }
+  let(:mock_file) {
+    mock_io = StringIO.new
+    allow(mock_io).to receive(:path).and_return('/dev/null')
+    mock_io
+  }
+
+  let(:mock_dir) { '/tmp' }
 
   let(:destination) { tmpfile('forge_module_release') }
 

data/spec/unit/functions/assert_type_spec.rb

@@ -28,7 +28,7 @@ describe 'the assert_type function' do
   it 'checks that first argument is a type' do
     expect do
       func.call({}, 10, 10)
-    end.to raise_error(ArgumentError, "The function 'assert_type' was called with arguments it does not accept. It expects one of:
+    end.to raise_error(ArgumentError, "'assert_type' expects one of:
   (Type type, Any value, Callable[Type, Type] block?)
     rejected: parameter 'type' expects a Type value, got Integer
   (String type_string, Any value, Callable[Type, Type] block?)

data/spec/unit/functions/camelcase_spec.rb

@@ -15,7 +15,7 @@ describe 'the camelcase function' do
     expect(compile_to_catalog("notify { String(42.camelcase == 42): }")).to have_resource('Notify[true]')
   end
 
-  it 'performs capitalize of international UTF-8 characters', :if => RUBY_VERSION >= "2.4" do
+  it 'performs camelcase of international UTF-8 characters' do
     expect(compile_to_catalog("notify { 'åäö_äö'.camelcase: }")).to have_resource('Notify[ÅäöÄö]')
   end