puppet 6.29.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/dipper_spec.rb

@@ -104,8 +104,8 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
           # Diff without the context
           # Lines we need to see match 'Content' instead of trimming diff output filter out
           # surrounding noise...or hard code the check values
-          if Puppet.runtime[:facter].value(:osfamily) == 'Solaris' &&
-            Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemrelease), '11.0') >= 0
+          if Facter.value(:osfamily) == 'Solaris' &&
+            Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.0') >= 0
             # Use gdiff on Solaris
             diff12 = Puppet::Util::Execution.execute("gdiff -uN #{file1} #{file2}| grep Content")
             diff21 = Puppet::Util::Execution.execute("gdiff -uN #{file2} #{file1}| grep Content")

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
@@ -155,29 +152,6 @@ describe Puppet::FileServing::Configuration::Parser do
     end
   end
 
-  describe Puppet::FileServing::Configuration::Parser, " when parsing the scripts mount" do
-    include FSConfigurationParserTesting
-
-    before do
-      @mount = double('scriptsmount', :name => "scripts", :validate => true)
-    end
-
-    it "should create an instance of the Scripts Mount class" do
-      write_config_file "[scripts]\n"
-
-      expect(Puppet::FileServing::Mount::Scripts).to receive(:new).with("scripts").and_return(@mount)
-      @parser.parse
-    end
-
-    it "should warn if a path is set" do
-      write_config_file "[scripts]\npath /some/path\n"
-      expect(Puppet::FileServing::Mount::Scripts).to receive(:new).with("scripts").and_return(@mount)
-
-      expect(Puppet).to receive(:warning)
-      @parser.parse
-    end
-  end
-
   describe Puppet::FileServing::Configuration::Parser, " when parsing the plugins mount" do
     include FSConfigurationParserTesting
 

data/spec/unit/file_serving/configuration_spec.rb

@@ -80,65 +80,49 @@ describe Puppet::FileServing::Configuration do
       expect(config.mounted?("one")).to be_truthy
     end
 
-    it "should add modules, plugins, scripts, and tasks mounts even if the file does not exist" do
+    it "should add modules, plugins, and tasks mounts even if the file does not exist" do
       expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("modules")).to be_truthy
       expect(config.mounted?("plugins")).to be_truthy
-      expect(config.mounted?("scripts")).to be_truthy
       expect(config.mounted?("tasks")).to be_truthy
     end
 
-    it "should allow all access to modules, plugins, scripts, and tasks if no fileserver.conf exists" 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('*')
 
-      scripts = double('scripts', :empty? => true)
-      allow(Puppet::FileServing::Mount::Scripts).to receive(:new).and_return(scripts)
-      expect(scripts).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
 
-    it "should not allow access from all to modules, plugins, scripts, and tasks if the fileserver.conf provided some rules" 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('*')
-
-      scripts = double('scripts', :empty? => false)
-      allow(Puppet::FileServing::Mount::Scripts).to receive(:new).and_return(scripts)
-      expect(scripts).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
 
-    it "should add modules, plugins, scripts, and tasks mounts even if they are not returned by the parser" do
+    it "should add modules, plugins, and tasks mounts even if they are not returned by the parser" do
       expect(@parser).to receive(:parse).and_return("one" => double("mount"))
       expect(Puppet::FileSystem).to receive(:exist?).and_return(true) # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("modules")).to be_truthy
       expect(config.mounted?("plugins")).to be_truthy
-      expect(config.mounted?("scripts")).to be_truthy
       expect(config.mounted?("tasks")).to be_truthy
     end
   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,19 +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
-
-    it "should not warn about misusage of BOM with non-UTF encoding" do
-      allow(Encoding).to receive(:default_external).and_return(Encoding::US_ASCII)
-      with_file_content("file content \n") do |file|
-        expect{ Puppet::FileSystem.read_preserve_line_endings(file) }.not_to output(/BOM with non-UTF encoding US-ASCII is nonsense/).to_stderr
-      end
-    end
   end
 
   context "read without an encoding specified" do
@@ -984,12 +971,11 @@ describe "Puppet::FileSystem" do
         end
 
         it 'preserves file ownership' do
-          FileUtils.touch(dest)
-          allow(File).to receive(:lstat).and_call_original
-          allow(File).to receive(:lstat).with(Pathname.new(dest)).and_return(double(uid: 1, gid: 2, 'directory?': false))
+          allow(Puppet::FileSystem).to receive(:lstat)
+            .with(Puppet::FileSystem.pathname(dest))
+            .and_return(double(uid: 1, gid: 2))
 
-          allow(File).to receive(:chown).and_call_original
-          expect(FileUtils).to receive(:chown).with(1, 2, any_args)
+          expect(FileUtils).to receive(:chown).with(1, 2, /#{dest}/)
 
           Puppet::FileSystem.replace_file(dest, 0644) { |f| f.write(content) }
         end
@@ -1013,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
 
@@ -1164,33 +1141,4 @@ describe "Puppet::FileSystem" do
       expect(File.mtime(dest)).to be_within(1).of(tomorrow)
     end
   end
-
-  context '#chmod' do
-    let(:dest) { tmpfile('abs_file') }
-
-    it "changes the mode given an absolute string" do
-      Puppet::FileSystem.touch(dest)
-      Puppet::FileSystem.chmod(0644, dest)
-      expect(File.stat(dest).mode & 0777).to eq(0644)
-    end
-
-    it "returns true if given an absolute pathname" do
-      Puppet::FileSystem.touch(dest)
-      Puppet::FileSystem.chmod(0644, Pathname.new(dest))
-      expect(File.stat(dest).mode & 0777).to eq(0644)
-    end
-
-    it "raises if the file doesn't exist" do
-      klass = Puppet::Util::Platform.windows? ? Puppet::Error : Errno::ENOENT
-      expect {
-        Puppet::FileSystem.chmod(0644, dest)
-      }.to raise_error(klass)
-    end
-
-    it "raises ArgumentError if dest is invalid" do
-      expect {
-        Puppet::FileSystem.chmod(0644, nil)
-      }.to raise_error(ArgumentError, /expected Pathname, got: 'NilClass'/)
-    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') }
 
@@ -90,7 +95,7 @@ describe Puppet::Forge::ModuleRelease do
         "checksums": { },
         "version": "#{module_version}",
         "description": "Standard Library for Puppet Modules",
-        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
+        "source": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
         "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "summary": "Puppet Module Standard Library",
         "dependencies": [
@@ -204,7 +209,7 @@ describe Puppet::Forge::ModuleRelease do
         "checksums": { },
         "version": "#{module_version}",
         "description": "Standard Library for Puppet Modules",
-        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
+        "source": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
         "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "summary": "Puppet Module Standard Library",
         "author": "#{module_author}",
@@ -279,7 +284,7 @@ describe Puppet::Forge::ModuleRelease do
         "checksums": { },
         "version": "#{module_version}",
         "description": "Standard Library for Puppet Modules",
-        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
+        "source": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
         "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
         "summary": "Puppet Module Standard Library",
         "dependencies": [

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
 

data/spec/unit/functions/capitalize_spec.rb

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

data/spec/unit/functions/downcase_spec.rb

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

data/spec/unit/functions/empty_spec.rb

@@ -56,16 +56,6 @@ describe 'the empty function' do
     end
   end
 
-  context 'for a sensitive string it' do
-    it 'returns true when empty' do
-      expect(compile_to_catalog("notify { String(empty(Sensitive(''))): }")).to have_resource('Notify[true]')
-    end
-
-    it 'returns false when not empty' do
-      expect(compile_to_catalog("notify { String(empty(Sensitive(' '))): }")).to have_resource('Notify[false]')
-    end
-  end
-
   context 'for a binary it' do
     it 'returns true when empty' do
       expect(compile_to_catalog("notify { String(empty(Binary(''))): }")).to have_resource('Notify[true]')

data/spec/unit/functions/logging_spec.rb

@@ -6,7 +6,6 @@ describe 'the log function' do
 
   def collect_logs(code)
     Puppet[:code] = code
-    Puppet[:environment_timeout] = 10
     node = Puppet::Node.new('logtest')
     compiler = Puppet::Parser::Compiler.new(node)
     node.environment.check_for_reparse