puppet 7.27.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -1,114 +0,0 @@
-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
-    @model = double('model')
-    @helper = Puppet::FileServing::TestHelper.new(@model)
-
-    @request = double('request', :key => "url", :options => {})
-
-    @fileset = double('fileset', :files => [], :path => "/my/file")
-    allow(Puppet::FileServing::Fileset).to receive(:new).with("/my/file", {}).and_return(@fileset)
-  end
-
-  it "should find a file with absolute path" do
-    file = double('file', :collect => nil)
-    expect(file).to receive(:collect).with(no_args)
-    expect(@model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(file)
-    @helper.path2instance(@request, "/my/file")
-  end
-
-  it "should pass through links, checksum_type, and source_permissions" do
-    file = double('file', :checksum_type= => nil, :links= => nil, :collect => nil)
-    [[:checksum_type, :sha256], [:links, true], [:source_permissions, :use]].each {|k, v|
-      expect(file).to receive(k.to_s+'=').with(v)
-      @request.options[k] = v
-    }
-    expect(file).to receive(:collect)
-    expect(@model).to receive(:new).with("/my/file", {:relative_path => :file}).and_return(file)
-    @helper.path2instance(@request, "/my/file", {:relative_path => :file})
-  end
-
-  it "should use a fileset to find paths" do
-    @fileset = double('fileset', :files => [], :path => "/my/files")
-    expect(Puppet::FileServing::Fileset).to receive(:new).with("/my/file", anything).and_return(@fileset)
-    @helper.path2instances(@request, "/my/file")
-  end
-
-  it "should support finding across multiple paths by merging the filesets" do
-    first = double('fileset', :files => [], :path => "/first/file")
-    expect(Puppet::FileServing::Fileset).to receive(:new).with("/first/file", anything).and_return(first)
-    second = double('fileset', :files => [], :path => "/second/file")
-    expect(Puppet::FileServing::Fileset).to receive(:new).with("/second/file", anything).and_return(second)
-
-    expect(Puppet::FileServing::Fileset).to receive(:merge).with(first, second).and_return({})
-
-    @helper.path2instances(@request, "/first/file", "/second/file")
-  end
-
-  it "should pass the indirection request to the Fileset at initialization" do
-    expect(Puppet::FileServing::Fileset).to receive(:new).with(anything, @request).and_return(@fileset)
-    @helper.path2instances(@request, "/my/file")
-  end
-
-  describe "when creating instances" do
-    before do
-      allow(@request).to receive(:key).and_return("puppet://host/mount/dir")
-
-      @one = double('one', :links= => nil, :collect => nil)
-      @two = double('two', :links= => nil, :collect => nil)
-
-      @fileset = double('fileset', :files => %w{one two}, :path => "/my/file")
-      allow(Puppet::FileServing::Fileset).to receive(:new).and_return(@fileset)
-    end
-
-    it "should set each returned instance's path to the original path" do
-      expect(@model).to receive(:new).with("/my/file", anything).and_return(@one, @two)
-      @helper.path2instances(@request, "/my/file")
-    end
-
-    it "should set each returned instance's relative path to the file-specific path" do
-      expect(@model).to receive(:new).with(anything, hash_including(relative_path: "one")).and_return(@one)
-      expect(@model).to receive(:new).with(anything, hash_including(relative_path: "two")).and_return(@two)
-      @helper.path2instances(@request, "/my/file")
-    end
-
-    it "should set the links value on each instance if one is provided" do
-      expect(@one).to receive(:links=).with(:manage)
-      expect(@two).to receive(:links=).with(:manage)
-      expect(@model).to receive(:new).and_return(@one, @two)
-
-      @request.options[:links] = :manage
-      @helper.path2instances(@request, "/my/file")
-    end
-
-    it "should set the request checksum_type if one is provided" do
-      expect(@one).to receive(:checksum_type=).with(:test)
-      expect(@two).to receive(:checksum_type=).with(:test)
-      expect(@model).to receive(:new).and_return(@one, @two)
-
-      @request.options[:checksum_type] = :test
-      @helper.path2instances(@request, "/my/file")
-    end
-
-    it "should collect the instance's attributes" do
-      expect(@one).to receive(:collect)
-      expect(@two).to receive(:collect)
-      expect(@model).to receive(:new).and_return(@one, @two)
-
-      @helper.path2instances(@request, "/my/file")
-    end
-  end
-end

data/spec/unit/file_serving/terminus_selector_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/file_serving/terminus_selector'
-
-describe Puppet::FileServing::TerminusSelector do
-  class TestSelector
-    include Puppet::FileServing::TerminusSelector
-  end
-
-  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
-      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
-      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
-      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
-      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
-      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
-      it "should choose :rest when a server is specified" do
-        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
-        Puppet[:server] = 'localhost'
-        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
-        Puppet[:default_file_terminus] = 'file_server'
-        request = create_request("puppet:///plugins")
-
-        expect(subject.select(request)).to eq(:file_server)
-      end
-    end
-  end
-end

data/spec/unit/file_system/path_pattern_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet/file_system'
-require 'puppet/util'
-
-describe Puppet::FileSystem::PathPattern do
-  include PuppetSpec::Files
-  InvalidPattern = Puppet::FileSystem::PathPattern::InvalidPattern
-
-  describe 'relative' do
-    it "can not be created with a traversal up the directory tree" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("my/../other")
-      end.to raise_error(InvalidPattern, "PathPatterns cannot be created with directory traversals.")
-    end
-
-    it "can be created with a '..' prefixing a filename" do
-      expect(Puppet::FileSystem::PathPattern.relative("my/..other").to_s).to eq("my/..other")
-    end
-
-    it "can be created with a '..' suffixing a filename" do
-      expect(Puppet::FileSystem::PathPattern.relative("my/other..").to_s).to eq("my/other..")
-    end
-
-    it "can be created with a '..' embedded in a filename" do
-      expect(Puppet::FileSystem::PathPattern.relative("my/ot..her").to_s).to eq("my/ot..her")
-    end
-
-    it "can not be created with a \\0 byte embedded" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("my/\0/other")
-      end.to raise_error(InvalidPattern, "PathPatterns cannot be created with a zero byte.")
-    end
-
-    it "can not be created with a windows drive" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("c:\\relative\\path")
-      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
-    end
-
-    it "can not be created with a windows drive (with space)" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative(" c:\\relative\\path")
-      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
-    end
-
-    it "can not create an absolute relative path" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("/no/absolutes")
-      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
-    end
-
-    it "can not create an absolute relative path (with space)" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("\t/no/absolutes")
-      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
-    end
-
-    it "can not create a relative path that is a windows path relative to the current drive" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("\\no\relatives")
-      end.to raise_error(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
-    end
-
-    it "creates a relative PathPattern from a valid relative path" do
-      expect(Puppet::FileSystem::PathPattern.relative("a/relative/path").to_s).to eq("a/relative/path")
-    end
-
-    it "is not absolute" do
-      expect(Puppet::FileSystem::PathPattern.relative("a/relative/path")).to_not be_absolute
-    end
-  end
-
-  describe 'absolute' do
-    it "can not create a relative absolute path" do
-      expect do
-        Puppet::FileSystem::PathPattern.absolute("no/relatives")
-      end.to raise_error(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
-    end
-
-    it "can not create an absolute path that is a windows path relative to the current drive" do
-      expect do
-        Puppet::FileSystem::PathPattern.absolute("\\no\\relatives")
-      end.to raise_error(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
-    end
-
-    it "creates an absolute PathPattern from a valid absolute path" do
-      expect(Puppet::FileSystem::PathPattern.absolute("/an/absolute/path").to_s).to eq("/an/absolute/path")
-    end
-
-    it "creates an absolute PathPattern from a valid Windows absolute path" do
-      expect(Puppet::FileSystem::PathPattern.absolute("c:/absolute/windows/path").to_s).to eq("c:/absolute/windows/path")
-    end
-
-    it "can be created with a '..' embedded in a filename on windows", :if => Puppet::Util::Platform.windows? do
-      expect(Puppet::FileSystem::PathPattern.absolute(%q{c:\..my\ot..her\one..}).to_s).to eq(%q{c:\..my\ot..her\one..})
-    end
-
-    it "is absolute" do
-      expect(Puppet::FileSystem::PathPattern.absolute("c:/absolute/windows/path")).to be_absolute
-    end
-  end
-
-  it "prefixes the relative path pattern with another path" do
-    pattern = Puppet::FileSystem::PathPattern.relative("docs/*_thoughts.txt")
-    prefix = Puppet::FileSystem::PathPattern.absolute("/prefix")
-
-    absolute_pattern = pattern.prefix_with(prefix)
-
-    expect(absolute_pattern).to be_absolute
-    expect(absolute_pattern.to_s).to eq(File.join("/prefix", "docs/*_thoughts.txt"))
-  end
-
-  it "refuses to prefix with a relative pattern" do
-    pattern = Puppet::FileSystem::PathPattern.relative("docs/*_thoughts.txt")
-    prefix = Puppet::FileSystem::PathPattern.relative("prefix")
-
-    expect do
-      pattern.prefix_with(prefix)
-    end.to raise_error(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
-  end
-
-  it "applies the pattern to the filesystem as a glob" do
-    dir = tmpdir('globtest')
-    create_file_in(dir, "found_one")
-    create_file_in(dir, "found_two")
-    create_file_in(dir, "third_not_found")
-
-    pattern = Puppet::FileSystem::PathPattern.relative("found_*").prefix_with(
-      Puppet::FileSystem::PathPattern.absolute(dir))
-
-    expect(pattern.glob).to match_array([File.join(dir, "found_one"),
-                                         File.join(dir, "found_two")])
-  end
-
-  it 'globs wildcard patterns properly' do
-    # See PUP-11788 and https://github.com/jruby/jruby/issues/7836.
-    pending 'JRuby does not properly handle Dir.glob' if Puppet::Util::Platform.jruby?
-
-    dir = tmpdir('globtest')
-    create_file_in(dir, 'foo.pp')
-    create_file_in(dir, 'foo.pp.pp')
-
-    pattern = Puppet::FileSystem::PathPattern.absolute(File.join(dir, '**/*.pp'))
-
-    expect(pattern.glob).to match_array([File.join(dir, 'foo.pp'),
-                                         File.join(dir, 'foo.pp.pp')])
-  end
-
-  def create_file_in(dir, name)
-    File.open(File.join(dir, name), "w") { |f| f.puts "data" }
-  end
-end

data/spec/unit/file_system/uniquefile_spec.rb

@@ -1,245 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::FileSystem::Uniquefile do
-  include PuppetSpec::Files
-
-  it "makes the name of the file available" do
-    Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-      expect(file.path).to match(/foo/)
-    end
-  end
-
-  it "ensures the file has permissions 0600", unless: Puppet::Util::Platform.windows? do
-    Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-      expect(Puppet::FileSystem.stat(file.path).mode & 07777).to eq(0600)
-    end
-  end
-
-  it "provides a writeable file" do
-    Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-      file.write("stuff")
-      file.flush
-
-      expect(Puppet::FileSystem.read(file.path)).to eq("stuff")
-    end
-  end
-
-  it "returns the value of the block" do
-    the_value = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-      "my value"
-    end
-
-    expect(the_value).to eq("my value")
-  end
-
-  it "unlinks the temporary file" do
-    filename = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-      file.path
-    end
-
-    expect(Puppet::FileSystem.exist?(filename)).to be_falsey
-  end
-
-  it "unlinks the temporary file even if the block raises an error" do
-    filename = nil
-
-    begin
-      Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-        filename = file.path
-        raise "error!"
-      end
-    rescue
-    end
-
-    expect(Puppet::FileSystem.exist?(filename)).to be_falsey
-  end
-
-  it "propagates lock creation failures" do
-    # use an arbitrary exception so as not accidentally collide
-    # with the ENOENT that occurs when trying to call rmdir
-    allow(Puppet::FileSystem::Uniquefile).to receive(:mkdir).and_raise('arbitrary failure')
-    expect(Puppet::FileSystem::Uniquefile).not_to receive(:rmdir)
-
-    expect {
-      Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
-    }.to raise_error('arbitrary failure')
-  end
-
-  it "only removes lock files that exist" do
-    # prevent the .lock directory from being created
-    allow(Puppet::FileSystem::Uniquefile).to receive(:mkdir)
-
-    # and expect cleanup to be skipped
-    expect(Puppet::FileSystem::Uniquefile).not_to receive(:rmdir)
-
-    Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
-  end
-
-  it "reports when a parent directory does not exist" do
-    dir = tmpdir('uniquefile')
-    lock = File.join(dir, 'path', 'to', 'lock')
-
-    expect {
-      Puppet::FileSystem::Uniquefile.new('foo', lock) { |tmp| }
-    }.to raise_error(Errno::ENOENT, %r{No such file or directory - A directory component in .* does not exist or is a dangling symbolic link})
-  end
-
-  it "should use UTF8 characters in TMP,TEMP,TMPDIR environment variable", :if => Puppet::Util::Platform.windows? do
-    rune_utf8 = "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7"
-    temp_rune_utf8 = File.join(Dir.tmpdir, rune_utf8)
-    Puppet::FileSystem.mkpath(temp_rune_utf8)
-
-    # Set the temporary environment variables to the UTF8 temp path
-    Puppet::Util::Windows::Process.set_environment_variable('TMPDIR', temp_rune_utf8)
-    Puppet::Util::Windows::Process.set_environment_variable('TMP', temp_rune_utf8)
-    Puppet::Util::Windows::Process.set_environment_variable('TEMP', temp_rune_utf8)
-
-    # Create a unique file
-    filename = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-      File.dirname(file.path)
-    end
-
-    expect(filename).to eq(temp_rune_utf8)
-  end
-
-  it "preserves tilde characters" do
-    Puppet::FileSystem::Uniquefile.open_tmp('~foo') do |file|
-      expect(File.basename(file.path)).to start_with('~foo')
-    end
-  end
-
-  context "Ruby 1.9.3 Tempfile tests" do
-    # the remaining tests in this file are ported directly from the ruby 1.9.3 source,
-    # since most of this file was ported from there
-    # see: https://github.com/ruby/ruby/blob/v1_9_3_547/test/test_tempfile.rb
-
-    def tempfile(*args, &block)
-      t = Puppet::FileSystem::Uniquefile.new(*args, &block)
-      @tempfile = (t unless block)
-    end
-
-    after(:each) do
-      if @tempfile
-        @tempfile.close!
-      end
-    end
-
-    it "creates tempfiles" do
-      t = tempfile("foo")
-      path = t.path
-      t.write("hello world")
-      t.close
-      expect(File.read(path)).to eq("hello world")
-    end
-
-    it "saves in tmpdir by default" do
-      t = tempfile("foo")
-      expect(Dir.tmpdir).to eq(File.dirname(t.path))
-    end
-
-    it "saves in given directory" do
-      subdir = File.join(Dir.tmpdir, "tempfile-test-#{rand}")
-      Dir.mkdir(subdir)
-      begin
-        tempfile = Tempfile.new("foo", subdir)
-        tempfile.close
-        begin
-          expect(subdir).to eq(File.dirname(tempfile.path))
-        ensure
-          tempfile.unlink
-        end
-      ensure
-        Dir.rmdir(subdir)
-      end
-    end
-
-    it "supports basename" do
-      t = tempfile("foo")
-      expect(File.basename(t.path)).to match(/^foo/)
-    end
-
-    it "supports basename with suffix" do
-      t = tempfile(["foo", ".txt"])
-      expect(File.basename(t.path)).to match(/^foo/)
-      expect(File.basename(t.path)).to match(/\.txt$/)
-    end
-
-    it "supports unlink" do
-      t = tempfile("foo")
-      path = t.path
-      t.close
-      expect(File.exist?(path)).to eq(true)
-      t.unlink
-      expect(File.exist?(path)).to eq(false)
-      expect(t.path).to eq(nil)
-    end
-
-    it "supports closing" do
-      t = tempfile("foo")
-      expect(t.closed?).to eq(false)
-      t.close
-      expect(t.closed?).to eq(true)
-    end
-
-    it "supports closing and unlinking via boolean argument" do
-      t = tempfile("foo")
-      path = t.path
-      t.close(true)
-      expect(t.closed?).to eq(true)
-      expect(t.path).to eq(nil)
-      expect(File.exist?(path)).to eq(false)
-    end
-
-    context "on unix platforms", :unless => Puppet::Util::Platform.windows? do
-      it "close doesn't unlink if already unlinked" do
-        t = tempfile("foo")
-        path = t.path
-        t.unlink
-        File.open(path, "w").close
-        begin
-          t.close(true)
-          expect(File.exist?(path)).to eq(true)
-        ensure
-          File.unlink(path) rescue nil
-        end
-      end
-    end
-
-    it "supports close!" do
-      t = tempfile("foo")
-      path = t.path
-      t.close!
-      expect(t.closed?).to eq(true)
-      expect(t.path).to eq(nil)
-      expect(File.exist?(path)).to eq(false)
-    end
-
-    context "on unix platforms", :unless => Puppet::Util::Platform.windows? do
-      it "close! doesn't unlink if already unlinked" do
-        t = tempfile("foo")
-        path = t.path
-        t.unlink
-        File.open(path, "w").close
-        begin
-          t.close!
-          expect(File.exist?(path)).to eq(true)
-        ensure
-          File.unlink(path) rescue nil
-        end
-      end
-    end
-
-    it "close does not make path nil" do
-      t = tempfile("foo")
-      t.close
-      expect(t.path.nil?).to eq(false)
-    end
-
-    it "close flushes buffer" do
-      t = tempfile("foo")
-      t.write("hello")
-      t.close
-      expect(File.size(t.path)).to eq(5)
-    end
-  end
-end