puppet 7.29.1-x64-mingw32 → 8.0.1-x64-mingw32

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/file_system'
+
+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
+
+  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

@@ -0,0 +1,245 @@
+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