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

data/spec/unit/provider/exec_spec.rb

@@ -1,244 +0,0 @@
-require 'spec_helper'
-require 'puppet/provider/exec'
-require 'puppet_spec/compiler'
-require 'puppet_spec/files'
-
-describe Puppet::Provider::Exec do
-  include PuppetSpec::Compiler
-  include PuppetSpec::Files
-
-  describe "#extractexe" do
-    it "should return the first element of an array" do
-      expect(subject.extractexe(['one', 'two'])).to eq('one')
-    end
-
-    {
-      # double-quoted commands
-      %q{"/has whitespace"}            => "/has whitespace",
-      %q{"/no/whitespace"}             => "/no/whitespace",
-      # singe-quoted commands
-      %q{'/has whitespace'}            => "/has whitespace",
-      %q{'/no/whitespace'}             => "/no/whitespace",
-      # combinations
-      %q{"'/has whitespace'"}          => "'/has whitespace'",
-      %q{'"/has whitespace"'}          => '"/has whitespace"',
-      %q{"/has 'special' characters"}  => "/has 'special' characters",
-      %q{'/has "special" characters'}  => '/has "special" characters',
-      # whitespace split commands
-      %q{/has whitespace}              => "/has",
-      %q{/no/whitespace}               => "/no/whitespace",
-    }.each do |base_command, exe|
-      ['', ' and args', ' "and args"', " 'and args'"].each do |args|
-        command = base_command + args
-        it "should extract #{exe.inspect} from #{command.inspect}" do
-          expect(subject.extractexe(command)).to eq(exe)
-        end
-      end
-    end
-  end
-
-  context "when handling sensitive data" do
-    before :each do
-      Puppet[:log_level] = 'debug'
-    end
-
-    let(:supersecret) { 'supersecret' }
-    let(:path) do
-      if Puppet::Util::Platform.windows?
-        # The `apply_compiled_manifest` helper doesn't add the `path` fact, so
-        # we can't reference that in our manifest. Windows PATHs can contain
-        # double quotes and trailing backslashes, which confuse HEREDOC
-        # interpolation below. So sanitize it:
-        ENV['PATH'].split(File::PATH_SEPARATOR)
-                   .map { |dir| dir.gsub(/"/, '\"').gsub(/\\$/, '') }
-                   .map { |dir| Pathname.new(dir).cleanpath.to_s }
-                   .join(File::PATH_SEPARATOR)
-      else
-        ENV['PATH']
-      end
-    end
-
-    def ruby_exit_0
-      "ruby -e 'exit 0'"
-    end
-
-    def echo_from_ruby_exit_0(message)
-      # Escape double quotes due to HEREDOC interpolation below
-      "ruby -e 'puts \"#{message}\"; exit 0'".gsub(/"/, '\"')
-    end
-
-    def echo_from_ruby_exit_1(message)
-      # Escape double quotes due to HEREDOC interpolation below
-      "ruby -e 'puts \"#{message}\"; exit 1'".gsub(/"/, '\"')
-    end
-
-    context "when validating the command" do
-      it "redacts the arguments if the command is relative" do
-        expect {
-          apply_compiled_manifest(<<-MANIFEST)
-            exec { 'echo':
-              command => Sensitive.new('echo #{supersecret}')
-            }
-          MANIFEST
-        }.to raise_error do |err|
-          expect(err).to be_a(Puppet::Error)
-          expect(err.message).to match(/'echo' is not qualified and no path was specified. Please qualify the command or specify a path./)
-          expect(err.message).to_not match(/#{supersecret}/)
-        end
-      end
-
-      it "redacts the arguments if the command is a directory" do
-        dir = tmpdir('exec')
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{dir} #{supersecret}'),
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /'#{dir}' is a directory, not a file/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-
-      it "redacts the arguments if the command isn't executable" do
-        file = tmpfile('exec')
-        Puppet::FileSystem.touch(file)
-        Puppet::FileSystem.chmod(0644, file)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{file} #{supersecret}'),
-          }
-        MANIFEST
-        # Execute permission works differently on Windows, but execute will fail since the
-        # file doesn't have a valid extension and isn't a valid executable. The raised error
-        # will be Errno::EIO, which is not useful. The Windows execute code needs to raise
-        # Puppet::Util::Windows::Error so the Win32 error message is preserved.
-        pending("PUP-3561 Needs to raise a meaningful Puppet::Error") if Puppet::Util::Platform.windows?
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /'#{file}' is not executable/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-
-      it "redacts the arguments if the relative command cannot be resolved using the path parameter" do
-        file = File.basename(tmpfile('exec'))
-        dir = tmpdir('exec')
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{file} #{supersecret}'),
-            path    => "#{dir}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /Could not find command '#{file}'/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-    end
-
-    it "redacts the command on success", unless: Puppet::Util::Platform.jruby? do
-      command = echo_from_ruby_exit_0(supersecret)
-
-      apply_compiled_manifest(<<-MANIFEST)
-        exec { 'true':
-          command => Sensitive.new("#{command}"),
-          path    => "#{path}",
-        }
-      MANIFEST
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-      expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-      expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-    end
-
-    it "redacts the command on failure", unless: Puppet::Util::Platform.jruby? do
-      command = echo_from_ruby_exit_1(supersecret)
-
-      apply_compiled_manifest(<<-MANIFEST)
-        exec { 'false':
-          command => Sensitive.new("#{command}"),
-          path    => "#{path}",
-        }
-      MANIFEST
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[false\]/))
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-      expect(@logs).to include(an_object_having_attributes(level: :err, message: "[command redacted] returned 1 instead of one of [0]"))
-      expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-    end
-
-    context "when handling checks", unless: Puppet::Util::Platform.jruby? do
-      let(:onlyifsecret) { "onlyifsecret" }
-      let(:unlesssecret) { "unlesssecret" }
-
-      it "redacts command and onlyif outputs" do
-        onlyif = echo_from_ruby_exit_0(onlyifsecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{ruby_exit_0}"),
-            onlyif  => Sensitive.new("#{onlyif}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{onlyifsecret}/))
-      end
-
-      it "redacts the command that would have been executed but didn't due to onlyif" do
-        command = echo_from_ruby_exit_0(supersecret)
-        onlyif = echo_from_ruby_exit_1(onlyifsecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{command}"),
-            onlyif  => Sensitive.new("#{onlyif}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "'[command redacted]' won't be executed because of failed check 'onlyif'"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{onlyifsecret}/))
-      end
-
-      it "redacts command and unless outputs" do
-        unlesscmd = echo_from_ruby_exit_1(unlesssecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{ruby_exit_0}"),
-            unless  => Sensitive.new("#{unlesscmd}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{unlesssecret}/))
-      end
-
-      it "redacts the command that would have been executed but didn't due to unless" do
-        command = echo_from_ruby_exit_0(supersecret)
-        unlesscmd = echo_from_ruby_exit_0(unlesssecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{command}"),
-            unless  => Sensitive.new("#{unlesscmd}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "'[command redacted]' won't be executed because of failed check 'unless'"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{unlesssecret}/))
-      end
-    end
-  end
-end

data/spec/unit/provider/file/posix_spec.rb

@@ -1,230 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix? do
-  include PuppetSpec::Files
-
-  let(:path) { tmpfile('posix_file_spec') }
-  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => '0777', :provider => described_class.name }
-  let(:provider) { resource.provider }
-
-  describe "#mode" do
-    it "should return a string with the higher-order bits stripped away" do
-      FileUtils.touch(path)
-      File.chmod(0644, path)
-
-      expect(provider.mode).to eq('0644')
-    end
-
-    it "should return absent if the file doesn't exist" do
-      expect(provider.mode).to eq(:absent)
-    end
-  end
-
-  describe "#mode=" do
-    it "should chmod the file to the specified value" do
-      FileUtils.touch(path)
-      File.chmod(0644, path)
-
-      provider.mode = '0755'
-
-      expect(provider.mode).to eq('0755')
-    end
-
-    it "should pass along any errors encountered" do
-      expect do
-        provider.mode = '0644'
-      end.to raise_error(Puppet::Error, /failed to set mode/)
-    end
-  end
-
-  describe "#uid2name" do
-    it "should return the name of the user identified by the id" do
-      allow(Etc).to receive(:getpwuid).with(501).and_return(Etc::Passwd.new('jilluser', nil, 501))
-
-      expect(provider.uid2name(501)).to eq('jilluser')
-    end
-
-    it "should return the argument if it's already a name" do
-      expect(provider.uid2name('jilluser')).to eq('jilluser')
-    end
-
-    it "should return nil if the argument is above the maximum uid" do
-      expect(provider.uid2name(Puppet[:maximum_uid] + 1)).to eq(nil)
-    end
-
-    it "should return nil if the user doesn't exist" do
-      expect(Etc).to receive(:getpwuid).and_raise(ArgumentError, "can't find user for 999")
-
-      expect(provider.uid2name(999)).to eq(nil)
-    end
-  end
-
-  describe "#name2uid" do
-    it "should return the id of the user if it exists" do
-      passwd = Etc::Passwd.new('bobbo', nil, 502)
-
-      allow(Etc).to receive(:getpwnam).with('bobbo').and_return(passwd)
-      allow(Etc).to receive(:getpwuid).with(502).and_return(passwd)
-
-      expect(provider.name2uid('bobbo')).to eq(502)
-    end
-
-    it "should return the argument if it's already an id" do
-      expect(provider.name2uid('503')).to eq(503)
-    end
-
-    it "should return false if the user doesn't exist" do
-      allow(Etc).to receive(:getpwnam).with('chuck').and_raise(ArgumentError, "can't find user for chuck")
-
-      expect(provider.name2uid('chuck')).to eq(false)
-    end
-  end
-
-  describe "#owner" do
-    it "should return the uid of the file owner" do
-      FileUtils.touch(path)
-      owner = Puppet::FileSystem.stat(path).uid
-
-      expect(provider.owner).to eq(owner)
-    end
-
-    it "should return absent if the file can't be statted" do
-      expect(provider.owner).to eq(:absent)
-    end
-
-    it "should warn and return :silly if the value is beyond the maximum uid" do
-      stat = double('stat', :uid => Puppet[:maximum_uid] + 1)
-      allow(resource).to receive(:stat).and_return(stat)
-
-      expect(provider.owner).to eq(:silly)
-      expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative UID/}
-    end
-  end
-
-  describe "#owner=" do
-    it "should set the owner but not the group of the file" do
-      expect(File).to receive(:lchown).with(15, nil, resource[:path])
-
-      provider.owner = 15
-    end
-
-    it "should chown a link if managing links" do
-      resource[:links] = :manage
-      expect(File).to receive(:lchown).with(20, nil, resource[:path])
-
-      provider.owner = 20
-    end
-
-    it "should chown a link target if following links" do
-      resource[:links] = :follow
-      expect(File).to receive(:chown).with(20, nil, resource[:path])
-
-      provider.owner = 20
-    end
-
-    it "should pass along any error encountered setting the owner" do
-      expect(File).to receive(:lchown).and_raise(ArgumentError)
-
-      expect { provider.owner = 25 }.to raise_error(Puppet::Error, /Failed to set owner to '25'/)
-    end
-  end
-
-  describe "#gid2name" do
-    it "should return the name of the group identified by the id" do
-      allow(Etc).to receive(:getgrgid).with(501).and_return(Etc::Passwd.new('unicorns', nil, nil, 501))
-
-      expect(provider.gid2name(501)).to eq('unicorns')
-    end
-
-    it "should return the argument if it's already a name" do
-      expect(provider.gid2name('leprechauns')).to eq('leprechauns')
-    end
-
-    it "should return nil if the argument is above the maximum gid" do
-      expect(provider.gid2name(Puppet[:maximum_uid] + 1)).to eq(nil)
-    end
-
-    it "should return nil if the group doesn't exist" do
-      expect(Etc).to receive(:getgrgid).and_raise(ArgumentError, "can't find group for 999")
-
-      expect(provider.gid2name(999)).to eq(nil)
-    end
-  end
-
-  describe "#name2gid" do
-    it "should return the id of the group if it exists" do
-      passwd = Etc::Passwd.new('penguins', nil, nil, 502)
-
-      allow(Etc).to receive(:getgrnam).with('penguins').and_return(passwd)
-      allow(Etc).to receive(:getgrgid).with(502).and_return(passwd)
-
-      expect(provider.name2gid('penguins')).to eq(502)
-    end
-
-    it "should return the argument if it's already an id" do
-      expect(provider.name2gid('503')).to eq(503)
-    end
-
-    it "should return false if the group doesn't exist" do
-      allow(Etc).to receive(:getgrnam).with('wombats').and_raise(ArgumentError, "can't find group for wombats")
-
-      expect(provider.name2gid('wombats')).to eq(false)
-    end
-
-  end
-
-  describe "#group" do
-    it "should return the gid of the file group" do
-      FileUtils.touch(path)
-      group = Puppet::FileSystem.stat(path).gid
-
-      expect(provider.group).to eq(group)
-    end
-
-    it "should return absent if the file can't be statted" do
-      expect(provider.group).to eq(:absent)
-    end
-
-    it "should warn and return :silly if the value is beyond the maximum gid" do
-      stat = double('stat', :gid => Puppet[:maximum_uid] + 1)
-      allow(resource).to receive(:stat).and_return(stat)
-
-      expect(provider.group).to eq(:silly)
-      expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative GID/}
-    end
-  end
-
-  describe "#group=" do
-    it "should set the group but not the owner of the file" do
-      expect(File).to receive(:lchown).with(nil, 15, resource[:path])
-
-      provider.group = 15
-    end
-
-    it "should change the group for a link if managing links" do
-      resource[:links] = :manage
-      expect(File).to receive(:lchown).with(nil, 20, resource[:path])
-
-      provider.group = 20
-    end
-
-    it "should change the group for a link target if following links" do
-      resource[:links] = :follow
-      expect(File).to receive(:chown).with(nil, 20, resource[:path])
-
-      provider.group = 20
-    end
-
-    it "should pass along any error encountered setting the group" do
-      expect(File).to receive(:lchown).and_raise(ArgumentError)
-
-      expect { provider.group = 25 }.to raise_error(Puppet::Error, /Failed to set group to '25'/)
-    end
-  end
-
-  describe "when validating" do
-    it "should not perform any validation" do
-      resource.validate
-    end
-  end
-end

data/spec/unit/provider/file/windows_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-if Puppet::Util::Platform.windows?
-  require 'puppet/util/windows'
-  class WindowsSecurity
-    extend Puppet::Util::Windows::Security
-  end
-end
-
-describe Puppet::Type.type(:file).provider(:windows), :if => Puppet::Util::Platform.windows? do
-  include PuppetSpec::Files
-
-  let(:path) { tmpfile('windows_file_spec') }
-  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => '0777', :provider => described_class.name }
-  let(:provider) { resource.provider }
-  let(:sid)      { 'S-1-1-50' }
-  let(:account)  { 'quinn' }
-
-  describe "#mode" do
-    it "should return a string representing the mode in 4-digit octal notation" do
-      FileUtils.touch(path)
-      WindowsSecurity.set_mode(0644, path)
-
-      expect(provider.mode).to eq('0644')
-    end
-
-    it "should return absent if the file doesn't exist" do
-      expect(provider.mode).to eq(:absent)
-    end
-  end
-
-  describe "#mode=" do
-    it "should chmod the file to the specified value" do
-      FileUtils.touch(path)
-      WindowsSecurity.set_mode(0644, path)
-
-      provider.mode = '0755'
-
-      expect(provider.mode).to eq('0755')
-    end
-
-    it "should pass along any errors encountered" do
-      expect do
-        provider.mode = '0644'
-      end.to raise_error(Puppet::Error, /failed to set mode/)
-    end
-  end
-
-  describe "#id2name" do
-    it "should return the name of the user identified by the sid" do
-      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(sid).and_return(true)
-      expect(Puppet::Util::Windows::SID).to receive(:sid_to_name).with(sid).and_return(account)
-
-      expect(provider.id2name(sid)).to eq(account)
-    end
-
-    it "should return the argument if it's already a name" do
-      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(account).and_return(false)
-      expect(Puppet::Util::Windows::SID).not_to receive(:sid_to_name)
-
-      expect(provider.id2name(account)).to eq(account)
-    end
-
-    it "should return nil if the user doesn't exist" do
-      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(sid).and_return(true)
-      expect(Puppet::Util::Windows::SID).to receive(:sid_to_name).with(sid).and_return(nil)
-
-      expect(provider.id2name(sid)).to eq(nil)
-    end
-  end
-
-  describe "#name2id" do
-    it "should delegate to name_to_sid" do
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with(account).and_return(sid)
-
-      expect(provider.name2id(account)).to eq(sid)
-    end
-  end
-
-  describe "#owner" do
-    it "should return the sid of the owner if the file does exist" do
-      FileUtils.touch(resource[:path])
-      allow(provider).to receive(:get_owner).with(resource[:path]).and_return(sid)
-
-      expect(provider.owner).to eq(sid)
-    end
-
-    it "should return absent if the file doesn't exist" do
-      expect(provider.owner).to eq(:absent)
-    end
-  end
-
-  describe "#owner=" do
-    it "should set the owner to the specified value" do
-      expect(provider).to receive(:set_owner).with(sid, resource[:path])
-      provider.owner = sid
-    end
-
-    it "should propagate any errors encountered when setting the owner" do
-      allow(provider).to receive(:set_owner).and_raise(ArgumentError)
-
-      expect {
-        provider.owner = sid
-      }.to raise_error(Puppet::Error, /Failed to set owner/)
-    end
-  end
-
-  describe "#group" do
-    it "should return the sid of the group if the file does exist" do
-      FileUtils.touch(resource[:path])
-      allow(provider).to receive(:get_group).with(resource[:path]).and_return(sid)
-
-      expect(provider.group).to eq(sid)
-    end
-
-    it "should return absent if the file doesn't exist" do
-      expect(provider.group).to eq(:absent)
-    end
-  end
-
-  describe "#group=" do
-    it "should set the group to the specified value" do
-      expect(provider).to receive(:set_group).with(sid, resource[:path])
-      provider.group = sid
-    end
-
-    it "should propagate any errors encountered when setting the group" do
-      allow(provider).to receive(:set_group).and_raise(ArgumentError)
-
-      expect {
-        provider.group = sid
-      }.to raise_error(Puppet::Error, /Failed to set group/)
-    end
-  end
-
-  describe "when validating" do
-    {:owner => 'foo', :group => 'foo', :mode => '0777'}.each do |k,v|
-      it "should fail if the filesystem doesn't support ACLs and we're managing #{k}" do
-        allow_any_instance_of(described_class).to receive(:supports_acl?).and_return(false)
-
-        expect {
-          Puppet::Type.type(:file).new :path => path, k => v
-        }.to raise_error(Puppet::Error, /Can only manage owner, group, and mode on filesystems that support Windows ACLs, such as NTFS/)
-      end
-    end
-
-    it "should not fail if the filesystem doesn't support ACLs and we're not managing permissions" do
-      allow_any_instance_of(described_class).to receive(:supports_acl?).and_return(false)
-
-      Puppet::Type.type(:file).new :path => path
-    end
-  end
-end