puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/util/at_fork_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Util::AtFork' do
-  EXPECTED_HANDLER_METHODS = [:prepare, :parent, :child]
-
-  before :each do
-    Puppet::Util.class_exec do
-      remove_const(:AtFork) if defined?(Puppet::Util::AtFork)
-      const_set(:AtFork, Module.new)
-    end
-  end
-
-  after :each do
-    Puppet::Util.class_exec do
-      remove_const(:AtFork)
-    end
-  end
-
-  describe '.get_handler' do
-    context 'when on Solaris' do
-      before :each do
-        expect(Puppet::Util::Platform).to receive(:solaris?).and_return(true)
-      end
-
-      after :each do
-        Object.class_exec do
-          remove_const(:Fiddle) if const_defined?(:Fiddle)
-        end
-      end
-
-      def stub_solaris_handler(stub_noop_too = false)
-        allow(Puppet::Util::AtFork).to receive(:require_relative).with(anything) do |lib|
-          if lib == 'at_fork/solaris'
-            load 'puppet/util/at_fork/solaris.rb'
-            true
-          elsif stub_noop_too && lib == 'at_fork/noop'
-            Puppet::Util::AtFork.class_exec do
-              const_set(:Noop, Class.new)
-            end
-            true
-          else
-            false
-          end
-        end.and_return(true)
-
-        unless stub_noop_too
-          Object.class_exec do
-            const_set(:Fiddle, Module.new do
-              const_set(:TYPE_VOIDP, nil)
-              const_set(:TYPE_VOID,  nil)
-              const_set(:TYPE_INT,   nil)
-              const_set(:DLError,    Class.new(StandardError))
-              const_set(:Handle,     Class.new { def initialize(library = nil, flags = 0); end })
-              const_set(:Function,   Class.new { def initialize(ptr, args, ret_type, abi = 0); end })
-            end)
-          end
-        end
-
-        allow(TOPLEVEL_BINDING.eval('self')).to receive(:require).with(anything) do |lib|
-          if lib == 'fiddle'
-            raise LoadError, 'no fiddle' if stub_noop_too
-          else
-            Kernel.require lib
-          end
-          true
-        end.and_return(true)
-      end
-
-      it %q(should return the Solaris specific AtFork handler) do
-        allow(Puppet::Util::AtFork).to receive(:require_relative).with(anything) do |lib|
-          if lib == 'at_fork/solaris'
-            Puppet::Util::AtFork.class_exec do
-              const_set(:Solaris, Class.new)
-            end
-            true
-          else
-            false
-          end
-        end.and_return(true)
-        load 'puppet/util/at_fork.rb'
-        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Solaris)
-      end
-
-      it %q(should return the Noop handler when Fiddle could not be loaded) do
-        stub_solaris_handler(true)
-        load 'puppet/util/at_fork.rb'
-        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Noop)
-      end
-
-      it %q(should fail when libcontract cannot be loaded) do
-        stub_solaris_handler
-        expect(Fiddle::Handle).to receive(:new).with(/^libcontract.so.*/).and_raise(Fiddle::DLError, 'no such library')
-        expect { load 'puppet/util/at_fork.rb' }.to raise_error(Fiddle::DLError, 'no such library')
-      end
-
-      it %q(should fail when libcontract doesn't define all the necessary functions) do
-        stub_solaris_handler
-        handle = double('Fiddle::Handle')
-        expect(Fiddle::Handle).to receive(:new).with(/^libcontract.so.*/).and_return(handle)
-        expect(handle).to receive(:[]).and_raise(Fiddle::DLError, 'no such method')
-        expect { load 'puppet/util/at_fork.rb' }.to raise_error(Fiddle::DLError, 'no such method')
-      end
-
-      it %q(the returned Solaris specific handler should respond to the expected methods) do
-        stub_solaris_handler
-        handle = double('Fiddle::Handle')
-        expect(Fiddle::Handle).to receive(:new).with(/^libcontract.so.*/).and_return(handle)
-        allow(handle).to receive(:[]).and_return(nil)
-        allow(Fiddle::Function).to receive(:new).and_return(Proc.new {})
-        load 'puppet/util/at_fork.rb'
-        expect(Puppet::Util::AtFork.get_handler.public_methods).to include(*EXPECTED_HANDLER_METHODS)
-      end
-    end
-
-    context 'when NOT on Solaris' do
-      before :each do
-        expect(Puppet::Util::Platform).to receive(:solaris?).and_return(false)
-      end
-
-      def stub_noop_handler(namespace_only = false)
-        allow(Puppet::Util::AtFork).to receive(:require_relative).with(anything) do |lib|
-          if lib == 'at_fork/noop'
-            if namespace_only
-              Puppet::Util::AtFork.class_exec do
-                const_set(:Noop, Class.new)
-              end
-            else
-              load 'puppet/util/at_fork/noop.rb'
-            end
-            true
-          else
-            false
-          end
-        end.and_return(true)
-      end
-
-      it %q(should return the Noop AtFork handler) do
-        stub_noop_handler(true)
-        load 'puppet/util/at_fork.rb'
-        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Noop)
-      end
-
-      it %q(the returned Noop handler should respond to the expected methods) do
-        stub_noop_handler
-        load 'puppet/util/at_fork.rb'
-        expect(Puppet::Util::AtFork.get_handler.public_methods).to include(*EXPECTED_HANDLER_METHODS)
-      end
-    end
-  end
-end

data/spec/unit/util/autoload_spec.rb

@@ -1,330 +0,0 @@
-require 'spec_helper'
-require 'fileutils'
-
-require 'puppet/util/autoload'
-
-describe Puppet::Util::Autoload do
-  include PuppetSpec::Files
-
-  let(:env) { Puppet::Node::Environment.create(:foo, []) }
-
-  before do
-    @autoload = Puppet::Util::Autoload.new("foo", "tmp")
-
-    @loaded = {}
-    allow(@autoload.class).to receive(:loaded).and_return(@loaded)
-  end
-
-  describe "when building the search path" do
-    before :each do
-      ## modulepath/libdir can't be used until after app settings are initialized, so we need to simulate that:
-      allow(Puppet.settings).to receive(:app_defaults_initialized?).and_return(true)
-    end
-
-    def with_libdir(libdir)
-      begin
-        old_loadpath = $LOAD_PATH.dup
-        old_libdir = Puppet[:libdir]
-        Puppet[:libdir] = libdir
-        $LOAD_PATH.unshift(libdir)
-        yield
-      ensure
-        Puppet[:libdir] = old_libdir
-        $LOAD_PATH.clear
-        $LOAD_PATH.concat(old_loadpath)
-      end
-    end
-
-    it "should collect all of the lib directories that exist in the current environment's module path" do
-      dira = dir_containing('dir_a', {
-        "one" => {},
-        "two" => { "lib" => {} }
-      })
-
-      dirb = dir_containing('dir_a', {
-        "one" => {},
-        "two" => { "lib" => {} }
-      })
-
-      environment = Puppet::Node::Environment.create(:foo, [dira, dirb])
-
-      expect(@autoload.class.module_directories(environment)).to eq(["#{dira}/two/lib", "#{dirb}/two/lib"])
-    end
-
-    it "ignores missing module directories" do
-      environment = Puppet::Node::Environment.create(:foo, [File.expand_path('does/not/exist')])
-
-      expect(@autoload.class.module_directories(environment)).to be_empty
-    end
-
-    it "ignores the configured environment when it doesn't exist" do
-      Puppet[:environment] = 'nonexistent'
-
-      env = Puppet::Node::Environment.create(:dev, [])
-      Puppet.override(environments: Puppet::Environments::Static.new(env)) do
-        expect(@autoload.class.module_directories(Puppet.lookup(:current_environment))).to be_empty
-      end
-    end
-
-    it "raises when no environment is given" do
-      Puppet[:environment] = 'nonexistent'
-
-      Puppet.override(environments: Puppet::Environments::Static.new) do
-        expect {
-          @autoload.class.module_directories(nil)
-        }.to raise_error(ArgumentError, /Autoloader requires an environment/)
-      end
-    end
-
-    it "should include the module directories, the Puppet libdir, Ruby load directories, and vendored modules" do
-      vendor_dir = tmpdir('vendor_modules')
-      module_libdir = File.join(vendor_dir, 'amodule_core', 'lib')
-      FileUtils.mkdir_p(module_libdir)
-
-      libdir = File.expand_path('/libdir1')
-      Puppet[:vendormoduledir] = vendor_dir
-      Puppet.initialize_settings
-
-      with_libdir(libdir) do
-        expect(@autoload.class).to receive(:gem_directories).and_return(%w{/one /two})
-        expect(@autoload.class).to receive(:module_directories).and_return(%w{/three /four})
-        dirs = @autoload.class.search_directories(nil)
-        expect(dirs[0..4]).to eq(%w{/one /two /three /four} + [libdir])
-        expect(dirs.last).to eq(module_libdir)
-      end
-    end
-
-    it "does not split the Puppet[:libdir]" do
-      dir = File.expand_path("/libdir1#{File::PATH_SEPARATOR}/libdir2")
-      with_libdir(dir) do
-        expect(@autoload.class).to receive(:gem_directories).and_return(%w{/one /two})
-        expect(@autoload.class).to receive(:module_directories).and_return(%w{/three /four})
-        dirs = @autoload.class.search_directories(nil)
-        expect(dirs).to include(dir)
-      end
-    end
-  end
-
-  describe "when loading a file" do
-    before do
-      allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a")])
-      allow(FileTest).to receive(:directory?).and_return(true)
-      @time_a = Time.utc(2010, 'jan', 1, 6, 30)
-      allow(File).to receive(:mtime).and_return(@time_a)
-    end
-
-    after(:each) do
-      $LOADED_FEATURES.delete("/a/tmp/myfile.rb")
-    end
-
-    [RuntimeError, LoadError, SyntaxError].each do |error|
-      it "should die with Puppet::Error if a #{error.to_s} exception is thrown" do
-        allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-
-        expect(Kernel).to receive(:load).and_raise(error)
-
-        expect { @autoload.load("foo", env) }.to raise_error(Puppet::Error)
-      end
-    end
-
-    it "should not raise an error if the file is missing" do
-      expect(@autoload.load("foo", env)).to eq(false)
-    end
-
-    it "should register loaded files with the autoloader" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
-      @autoload.load("myfile", env)
-
-      expect(@autoload.class.loaded?("tmp/myfile.rb")).to be
-    end
-
-    it "should be seen by loaded? on the instance using the short name" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
-      @autoload.load("myfile", env)
-
-      expect(@autoload.loaded?("myfile.rb")).to be
-    end
-
-    it "should register loaded files with the main loaded file list so they are not reloaded by ruby" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
-
-      @autoload.load("myfile", env)
-
-      expect($LOADED_FEATURES).to be_include(make_absolute("/a/tmp/myfile.rb"))
-    end
-
-    it "should load the first file in the searchpath" do
-      allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a"), make_absolute("/b")])
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      expect(Kernel).to receive(:load).with(make_absolute("/a/tmp/myfile.rb"), any_args)
-
-      @autoload.load("myfile", env)
-    end
-
-    it "should treat equivalent paths to a loaded file as loaded" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
-      @autoload.load("myfile", env)
-
-      expect(@autoload.class.loaded?("tmp/myfile")).to be
-      expect(@autoload.class.loaded?("tmp/./myfile.rb")).to be
-      expect(@autoload.class.loaded?("./tmp/myfile.rb")).to be
-      expect(@autoload.class.loaded?("tmp/../tmp/myfile.rb")).to be
-    end
-  end
-
-  describe "when loading all files" do
-    let(:basedir) { tmpdir('autoloader') }
-    let(:path) { File.join(basedir, @autoload.path, 'file.rb') }
-
-    before do
-      FileUtils.mkdir_p(File.dirname(path))
-      FileUtils.touch(path)
-
-      allow(@autoload.class).to receive(:search_directories).and_return([basedir])
-    end
-
-    [RuntimeError, LoadError, SyntaxError].each do |error|
-      it "should die an if a #{error.to_s} exception is thrown" do
-        expect(Kernel).to receive(:load).and_raise(error)
-
-        expect { @autoload.loadall(env) }.to raise_error(Puppet::Error)
-      end
-    end
-
-    it "should require the full path to the file" do
-      expect(Kernel).to receive(:load).with(path, any_args)
-
-      @autoload.loadall(env)
-    end
-
-    it "autoloads from a directory whose ancestor is Windows 8.3", if: Puppet::Util::Platform.windows? do
-      # File.expand_path will expand ~ in the last directory component only(!)
-      # so create an ancestor directory with a long path
-      dir = File.join(tmpdir('longpath'), 'short')
-      path = File.join(dir, @autoload.path, 'file.rb')
-
-      FileUtils.mkdir_p(File.dirname(path))
-      FileUtils.touch(path)
-
-      dir83 = File.join(File.dirname(basedir), 'longpa~1', 'short')
-      path83 = File.join(dir83, @autoload.path, 'file.rb')
-
-      allow(@autoload.class).to receive(:search_directories).and_return([dir83])
-      expect(Kernel).to receive(:load).with(path83, any_args)
-
-      @autoload.loadall(env)
-    end
-  end
-
-  describe "when reloading files" do
-    before :each do
-      @file_a = make_absolute("/a/file.rb")
-      @file_b = make_absolute("/b/file.rb")
-      @first_time = Time.utc(2010, 'jan', 1, 6, 30)
-      @second_time = @first_time + 60
-    end
-
-    after :each do
-      $LOADED_FEATURES.delete("a/file.rb")
-      $LOADED_FEATURES.delete("b/file.rb")
-    end
-
-    it "#changed? should return true for a file that was not loaded" do
-      expect(@autoload.class.changed?(@file_a, env)).to be
-    end
-
-    it "changes should be seen by changed? on the instance using the short name" do
-      allow(File).to receive(:mtime).and_return(@first_time)
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
-      @autoload.load("myfile", env)
-      expect(@autoload.loaded?("myfile")).to be
-      expect(@autoload.changed?("myfile", env)).not_to be
-
-      allow(File).to receive(:mtime).and_return(@second_time)
-      expect(@autoload.changed?("myfile", env)).to be
-
-      $LOADED_FEATURES.delete("tmp/myfile.rb")
-    end
-
-    describe "in one directory" do
-      before :each do
-        allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a")])
-        expect(File).to receive(:mtime).with(@file_a).and_return(@first_time)
-        @autoload.class.mark_loaded("file", @file_a)
-      end
-
-      it "should reload if mtime changes" do
-        allow(File).to receive(:mtime).with(@file_a).and_return(@first_time + 60)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_a).and_return(true)
-        expect(Kernel).to receive(:load).with(@file_a, any_args)
-        @autoload.class.reload_changed(env)
-      end
-
-      it "should do nothing if the file is deleted" do
-        allow(File).to receive(:mtime).with(@file_a).and_raise(Errno::ENOENT)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_a).and_return(false)
-        expect(Kernel).not_to receive(:load)
-        @autoload.class.reload_changed(env)
-      end
-    end
-
-    describe "in two directories" do
-      before :each do
-        allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a"), make_absolute("/b")])
-      end
-
-      it "should load b/file when a/file is deleted" do
-        expect(File).to receive(:mtime).with(@file_a).and_return(@first_time)
-        @autoload.class.mark_loaded("file", @file_a)
-        allow(File).to receive(:mtime).with(@file_a).and_raise(Errno::ENOENT)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_a).and_return(false)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_b).and_return(true)
-        allow(File).to receive(:mtime).with(@file_b).and_return(@first_time)
-        expect(Kernel).to receive(:load).with(@file_b, any_args)
-        @autoload.class.reload_changed(env)
-        expect(@autoload.class.send(:loaded)["file"]).to eq([@file_b, @first_time])
-      end
-
-      it "should load a/file when b/file is loaded and a/file is created" do
-        allow(File).to receive(:mtime).with(@file_b).and_return(@first_time)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_b).and_return(true)
-        @autoload.class.mark_loaded("file", @file_b)
-
-        allow(File).to receive(:mtime).with(@file_a).and_return(@first_time)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_a).and_return(true)
-        expect(Kernel).to receive(:load).with(@file_a, any_args)
-        @autoload.class.reload_changed(env)
-        expect(@autoload.class.send(:loaded)["file"]).to eq([@file_a, @first_time])
-      end
-    end
-  end
-
-  describe "#cleanpath" do
-    it "should leave relative paths relative" do
-      path = "hello/there"
-      expect(Puppet::Util::Autoload.cleanpath(path)).to eq(path)
-    end
-
-    describe "on Windows", :if => Puppet::Util::Platform.windows? do
-      it "should convert c:\ to c:/" do
-        expect(Puppet::Util::Autoload.cleanpath('c:\\')).to eq('c:/')
-      end
-
-      it "should convert all backslashes to forward slashes" do
-        expect(Puppet::Util::Autoload.cleanpath('c:\projects\ruby\bug\test.rb')).to eq('c:/projects/ruby/bug/test.rb')
-      end
-    end
-  end
-
-  describe "#expand" do
-    it "should expand relative to the autoloader's prefix" do
-      expect(@autoload.expand('bar')).to eq('tmp/bar')
-    end
-  end
-end

data/spec/unit/util/backups_spec.rb

@@ -1,130 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/backups'
-
-describe Puppet::Util::Backups do
-  include PuppetSpec::Files
-
-  let(:bucket) { double('bucket', :name => "foo") }
-  let!(:file) do
-    f = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
-    allow(f).to receive(:bucket).and_return(bucket)
-    f
-  end
-
-  describe "when backing up a file" do
-    let(:path) { make_absolute('/no/such/file') }
-
-    it "should noop if the file does not exist" do
-      expect(file).not_to receive(:bucket)
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
-
-      file.perform_backup
-    end
-
-    it "should succeed silently if self[:backup] is false" do
-      file = Puppet::Type.type(:file).new(:name => path, :backup => false)
-
-      expect(file).not_to receive(:bucket)
-      expect(Puppet::FileSystem).not_to receive(:exist?)
-
-      file.perform_backup
-    end
-
-    it "a bucket should be used when provided" do
-      lstat_path_as(path, 'file')
-      expect(bucket).to receive(:backup).with(path).and_return("mysum")
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-
-      file.perform_backup
-    end
-
-    it "should propagate any exceptions encountered when backing up to a filebucket" do
-      lstat_path_as(path, 'file')
-      expect(bucket).to receive(:backup).and_raise(ArgumentError)
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-
-      expect { file.perform_backup }.to raise_error(ArgumentError)
-    end
-
-    describe "and local backup is configured" do
-      let(:ext) { 'foobkp' }
-      let(:backup) { path + '.' + ext }
-      let(:file) { Puppet::Type.type(:file).new(:name => path, :backup => '.'+ext) }
-
-      it "should remove any local backup if one exists" do
-        lstat_path_as(backup, 'file')
-        expect(Puppet::FileSystem).to receive(:unlink).with(backup)
-        allow(FileUtils).to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-
-        file.perform_backup
-      end
-
-      it "should fail when the old backup can't be removed" do
-        lstat_path_as(backup, 'file')
-        expect(Puppet::FileSystem).to receive(:unlink).with(backup).and_raise(ArgumentError)
-        expect(FileUtils).not_to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-
-        expect { file.perform_backup }.to raise_error(Puppet::Error)
-      end
-
-      it "should not try to remove backups that don't exist" do
-        expect(Puppet::FileSystem).to receive(:lstat).with(backup).and_raise(Errno::ENOENT)
-        expect(Puppet::FileSystem).not_to receive(:unlink).with(backup)
-        allow(FileUtils).to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-
-        file.perform_backup
-      end
-
-      it "a copy should be created in the local directory" do
-        expect(FileUtils).to receive(:cp_r).with(path, backup, {:preserve => true})
-        allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-
-        expect(file.perform_backup).to be_truthy
-      end
-
-      it "should propagate exceptions if no backup can be created" do
-        expect(FileUtils).to receive(:cp_r).and_raise(ArgumentError)
-
-        allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect { file.perform_backup }.to raise_error(Puppet::Error)
-      end
-    end
-  end
-
-  describe "when backing up a directory" do
-    let(:path) { make_absolute('/my/dir') }
-    let(:filename) { File.join(path, 'file') }
-
-    it "a bucket should work when provided" do
-      allow(File).to receive(:file?).with(filename).and_return(true)
-      expect(Find).to receive(:find).with(path).and_yield(filename)
-
-      expect(bucket).to receive(:backup).with(filename).and_return(true)
-
-      lstat_path_as(path, 'directory')
-
-      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).with(filename).and_return(true)
-
-      file.perform_backup
-    end
-
-    it "should do nothing when recursing" do
-      file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo', :recurse => true)
-
-      expect(bucket).not_to receive(:backup)
-      allow(Puppet::FileSystem).to receive(:stat).with(path).and_return(double('stat', :ftype => 'directory'))
-      expect(Find).not_to receive(:find)
-
-      file.perform_backup
-    end
-  end
-
-  def lstat_path_as(path, ftype)
-    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double('File::Stat', :ftype => ftype))
-  end
-end