puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/provider/command_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/provider/command'
-
-describe Puppet::Provider::Command do
-  let(:name) { "the name" }
-  let(:the_options) { { :option => 1 } }
-  let(:no_options) { {} }
-  let(:executable) { "foo" }
-  let(:executable_absolute_path) { "/foo/bar" }
-
-  let(:executor) { double('executor') }
-  let(:resolver) { double('resolver') }
-
-  let(:path_resolves_to_itself) do
-    resolves = Object.new
-    class << resolves
-      def which(path)
-        path
-      end
-    end
-    resolves
-  end
-
-  it "executes a simple command" do
-    expect(executor).to receive(:execute).with([executable], no_options)
-
-    command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor)
-    command.execute()
-  end
-
-  it "executes a command with extra options" do
-    expect(executor).to receive(:execute).with([executable], the_options)
-
-    command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor, the_options)
-    command.execute()
-  end
-
-  it "executes a command with arguments" do
-    expect(executor).to receive(:execute).with([executable, "arg1", "arg2"], no_options)
-
-    command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor)
-    command.execute("arg1", "arg2")
-  end
-
-  it "resolves to an absolute path for better execution" do
-    expect(resolver).to receive(:which).with(executable).and_return(executable_absolute_path)
-    expect(executor).to receive(:execute).with([executable_absolute_path], no_options)
-
-    command = Puppet::Provider::Command.new(name, executable, resolver, executor)
-    command.execute()
-  end
-
-  it "errors when the executable resolves to nothing" do
-    expect(resolver).to receive(:which).with(executable).and_return(nil)
-    expect(executor).not_to receive(:execute)
-
-    command = Puppet::Provider::Command.new(name, executable, resolver, executor)
-
-    expect { command.execute() }.to raise_error(Puppet::Error, "Command #{name} is missing")
-  end
-end

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

@@ -1,232 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix? do
-  include PuppetSpec::Files
-
-  def make_exe
-    cmdpath = tmpdir('cmdpath')
-    exepath = tmpfile('my_command', cmdpath)
-    FileUtils.touch(exepath)
-    File.chmod(0755, exepath)
-    exepath
-  end
-
-  let(:resource) { Puppet::Type.type(:exec).new(:title => '/foo', :provider => :posix) }
-  let(:provider) { described_class.new(resource) }
-
-  describe "#validatecmd" do
-    it "should fail if no path is specified and the command is not fully qualified" do
-      expect { provider.validatecmd("foo") }.to raise_error(
-        Puppet::Error,
-        "'foo' is not qualified and no path was specified. Please qualify the command or specify a path."
-      )
-    end
-
-    it "should pass if a path is given" do
-      provider.resource[:path] = ['/bogus/bin']
-      provider.validatecmd("../foo")
-    end
-
-    it "should pass if command is fully qualifed" do
-      provider.resource[:path] = ['/bogus/bin']
-      provider.validatecmd("/bin/blah/foo")
-    end
-  end
-
-  describe "#run" do
-    describe "when the command is an absolute path" do
-      let(:command) { tmpfile('foo') }
-
-      it "should fail if the command doesn't exist" do
-        expect { provider.run(command) }.to raise_error(ArgumentError, "Could not find command '#{command}'")
-      end
-
-      it "should fail if the command isn't a file" do
-        FileUtils.mkdir(command)
-        FileUtils.chmod(0755, command)
-
-        expect { provider.run(command) }.to raise_error(ArgumentError, "'#{command}' is a directory, not a file")
-      end
-
-      it "should fail if the command isn't executable" do
-        FileUtils.touch(command)
-        allow(File).to receive(:executable?).with(command).and_return(false)
-
-        expect { provider.run(command) }.to raise_error(ArgumentError, "'#{command}' is not executable")
-      end
-    end
-
-    describe "when the command is a relative path" do
-      it "should execute the command if it finds it in the path and is executable" do
-        command = make_exe
-        provider.resource[:path] = [File.dirname(command)]
-        filename = File.basename(command)
-
-        expect(Puppet::Util::Execution).to receive(:execute).with(filename, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-
-        provider.run(filename)
-      end
-
-      it "should fail if the command isn't in the path" do
-        resource[:path] = ["/fake/path"]
-
-        expect { provider.run('foo') }.to raise_error(ArgumentError, "Could not find command 'foo'")
-      end
-
-      it "should fail if the command is in the path but not executable" do
-        command = make_exe
-        File.chmod(0644, command)
-        allow(FileTest).to receive(:executable?).with(command).and_return(false)
-        resource[:path] = [File.dirname(command)]
-        filename = File.basename(command)
-
-        expect { provider.run(filename) }.to raise_error(ArgumentError, "Could not find command '#{filename}'")
-      end
-    end
-
-    it "should not be able to execute shell builtins" do
-      provider.resource[:path] = ['/bogus/bin']
-      expect { provider.run("cd ..") }.to raise_error(ArgumentError, "Could not find command 'cd'")
-    end
-
-    it "should execute the command if the command given includes arguments or subcommands" do
-      provider.resource[:path] = ['/bogus/bin']
-      command = make_exe
-
-      expect(Puppet::Util::Execution).to receive(:execute).with("#{command} bar --sillyarg=true --blah", instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-
-      provider.run("#{command} bar --sillyarg=true --blah")
-    end
-
-    it "should fail if quoted command doesn't exist" do
-      provider.resource[:path] = ['/bogus/bin']
-      command = "/foo bar --sillyarg=true --blah"
-
-      expect { provider.run(%Q["#{command}"]) }.to raise_error(ArgumentError, "Could not find command '#{command}'")
-    end
-
-    it "should warn if you're overriding something in environment" do
-      provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
-      command = make_exe
-
-      expect(Puppet::Util::Execution).to receive(:execute).with(command, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-
-      provider.run(command)
-
-      expect(@logs.map {|l| "#{l.level}: #{l.message}" }).to eq(["warning: Overriding environment setting 'WHATEVER' with '/foo'"])
-    end
-
-    it "should warn when setting an empty environment variable" do
-      provider.resource[:environment] = ['WHATEVER=']
-      command = make_exe
-
-      expect(Puppet::Util::Execution).to receive(:execute).with(command, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-
-      provider.run(command)
-
-      expect(@logs.map(&:to_s).join).to match(/Empty environment setting 'WHATEVER'\n\s+\(file & line not available\)/m)
-    end
-
-    it "should warn when setting an empty environment variable (within a manifest)" do
-      provider.resource[:environment] = ['WHATEVER=']
-      provider.resource.file = '/tmp/foobar'
-      provider.resource.line = 42
-      command = make_exe
-
-      expect(Puppet::Util::Execution).to receive(:execute).with(command, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-
-      provider.run(command)
-
-      expect(@logs.map(&:to_s).join).to match(/Empty environment setting 'WHATEVER'\n\s+\(file: \/tmp\/foobar, line: 42\)/m)
-    end
-
-    it "should set umask before execution if umask parameter is in use" do
-      provider.resource[:umask] = '0027'
-      expect(Puppet::Util).to receive(:withumask).with(0027)
-      provider.run(provider.resource[:command])
-    end
-
-    describe "posix locale settings", :unless => RUBY_PLATFORM == 'java' do
-      # a sentinel value that we can use to emulate what locale environment variables might be set to on an international
-      # system.
-      lang_sentinel_value = "en_US.UTF-8"
-      # a temporary hash that contains sentinel values for each of the locale environment variables that we override in
-      # "exec"
-      locale_sentinel_env = {}
-      Puppet::Util::POSIX::LOCALE_ENV_VARS.each { |var| locale_sentinel_env[var] = lang_sentinel_value }
-
-      command = "/bin/echo $%s"
-
-      it "should not override user's locale during execution" do
-        # we'll do this once without any sentinel values, to give us a little more test coverage
-        orig_env = {}
-        Puppet::Util::POSIX::LOCALE_ENV_VARS.each { |var| orig_env[var] = ENV[var] if ENV[var] }
-
-        orig_env.keys.each do |var|
-          output, _ = provider.run(command % var)
-          expect(output.strip).to eq(orig_env[var])
-        end
-
-        # now, once more... but with our sentinel values
-        Puppet::Util.withenv(locale_sentinel_env) do
-          Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-            output, _ = provider.run(command % var)
-            expect(output.strip).to eq(locale_sentinel_env[var])
-          end
-        end
-      end
-
-      it "should respect locale overrides in user's 'environment' configuration" do
-        provider.resource[:environment] = ['LANG=C', 'LC_ALL=C']
-        output, _ = provider.run(command % 'LANG')
-        expect(output.strip).to eq('C')
-        output, _ = provider.run(command % 'LC_ALL')
-        expect(output.strip).to eq('C')
-      end
-    end
-
-    describe "posix user-related environment vars", :unless => RUBY_PLATFORM == 'java' do
-      # a temporary hash that contains sentinel values for each of the user-related environment variables that we
-      # are expected to unset during an "exec"
-      user_sentinel_env = {}
-      Puppet::Util::POSIX::USER_ENV_VARS.each { |var| user_sentinel_env[var] = "Abracadabra" }
-
-      command = "/bin/echo $%s"
-
-      it "should unset user-related environment vars during execution" do
-        # first we set up a temporary execution environment with sentinel values for the user-related environment vars
-        # that we care about.
-        Puppet::Util.withenv(user_sentinel_env) do
-          # with this environment, we loop over the vars in question
-          Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
-            # ensure that our temporary environment is set up as we expect
-            expect(ENV[var]).to eq(user_sentinel_env[var])
-
-            # run an "exec" via the provider and ensure that it unsets the vars
-            output, _ = provider.run(command % var)
-            expect(output.strip).to eq("")
-
-            # ensure that after the exec, our temporary env is still intact
-            expect(ENV[var]).to eq(user_sentinel_env[var])
-          end
-
-        end
-      end
-
-      it "should respect overrides to user-related environment vars in caller's 'environment' configuration" do
-        sentinel_value = "Abracadabra"
-        # set the "environment" property of the resource, populating it with a hash containing sentinel values for
-        # each of the user-related posix environment variables
-        provider.resource[:environment] = Puppet::Util::POSIX::USER_ENV_VARS.collect { |var| "#{var}=#{sentinel_value}"}
-
-        # loop over the posix user-related environment variables
-        Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
-          # run an 'exec' to get the value of each variable
-          output, _ = provider.run(command % var)
-          # ensure that it matches our expected sentinel value
-          expect(output.strip).to eq(sentinel_value)
-        end
-      end
-    end
-  end
-end

data/spec/unit/provider/exec/shell_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:exec).provider(:shell),
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:resource) { Puppet::Type.type(:exec).new(:title => 'foo', :provider => 'shell') }
-  let(:provider) { described_class.new(resource) }
-
-  describe "#run" do
-    it "should be able to run builtin shell commands" do
-      output, status = provider.run("if [ 1 = 1 ]; then echo 'blah'; fi")
-      expect(status.exitstatus).to eq(0)
-      expect(output).to eq("blah\n")
-    end
-
-    it "should be able to run commands with single quotes in them" do
-      output, status = provider.run("echo 'foo  bar'")
-      expect(status.exitstatus).to eq(0)
-      expect(output).to eq("foo  bar\n")
-    end
-
-    it "should be able to run commands with double quotes in them" do
-      output, status = provider.run('echo "foo  bar"')
-      expect(status.exitstatus).to eq(0)
-      expect(output).to eq("foo  bar\n")
-    end
-
-    it "should be able to run multiple commands separated by a semicolon" do
-      output, status = provider.run("echo 'foo' ; echo 'bar'")
-      expect(status.exitstatus).to eq(0)
-      expect(output).to eq("foo\nbar\n")
-    end
-
-    it "should be able to read values from the environment parameter" do
-      resource[:environment] = "FOO=bar"
-      output, status = provider.run("echo $FOO")
-      expect(status.exitstatus).to eq(0)
-      expect(output).to eq("bar\n")
-    end
-
-    it "#14060: should interpolate inside the subshell, not outside it" do
-      resource[:environment] = "foo=outer"
-      output, status = provider.run("foo=inner; echo \"foo is $foo\"")
-      expect(status.exitstatus).to eq(0)
-      expect(output).to eq("foo is inner\n")
-    end
-  end
-
-  describe "#validatecmd" do
-    it "should always return true because builtins don't need path or to be fully qualified" do
-      expect(provider.validatecmd('whateverdoesntmatter')).to eq(true)
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet::Util::Platform.windows? do
-  include PuppetSpec::Files
-
-  let(:resource) { Puppet::Type.type(:exec).new(:title => 'C:\foo', :provider => :windows) }
-  let(:provider) { described_class.new(resource) }
-
-  after :all do
-    # This provider may not be suitable on some machines, so we want to reset
-    # the default so it isn't used by mistake in future specs.
-    Puppet::Type.type(:exec).defaultprovider = nil
-  end
-
-  describe "#extractexe" do
-    describe "when the command has no arguments" do
-      it "should return the command if it's quoted" do
-        expect(provider.extractexe('"foo"')).to eq('foo')
-      end
-
-      it "should return the command if it's quoted and contains spaces" do
-        expect(provider.extractexe('"foo bar"')).to eq('foo bar')
-      end
-
-      it "should return the command if it's not quoted" do
-        expect(provider.extractexe('foo')).to eq('foo')
-      end
-    end
-
-    describe "when the command has arguments" do
-      it "should return the command if it's quoted" do
-        expect(provider.extractexe('"foo" bar baz')).to eq('foo')
-      end
-
-      it "should return the command if it's quoted and contains spaces" do
-        expect(provider.extractexe('"foo bar" baz "quux quiz"')).to eq('foo bar')
-      end
-
-      it "should return the command if it's not quoted" do
-        expect(provider.extractexe('foo bar baz')).to eq('foo')
-      end
-    end
-  end
-
-  describe "#checkexe" do
-    describe "when the command is absolute", :if => Puppet::Util::Platform.windows? do
-      it "should return if the command exists and is a file" do
-        command = tmpfile('command')
-        FileUtils.touch(command)
-
-        expect(provider.checkexe(command)).to eq(nil)
-      end
-      it "should fail if the command doesn't exist" do
-        command = tmpfile('command')
-
-        expect { provider.checkexe(command) }.to raise_error(ArgumentError, "Could not find command '#{command}'")
-      end
-      it "should fail if the command isn't a file" do
-        command = tmpfile('command')
-        FileUtils.mkdir(command)
-
-        expect { provider.checkexe(command) }.to raise_error(ArgumentError, "'#{command}' is a directory, not a file")
-      end
-    end
-
-    describe "when the command is relative" do
-      describe "and a path is specified" do
-        before :each do
-          allow(provider).to receive(:which)
-        end
-
-        it "should search for executables with no extension" do
-          provider.resource[:path] = [File.expand_path('/bogus/bin')]
-          expect(provider).to receive(:which).with('foo').and_return('foo')
-
-          provider.checkexe('foo')
-        end
-
-        it "should fail if the command isn't in the path" do
-          expect { provider.checkexe('foo') }.to raise_error(ArgumentError, "Could not find command 'foo'")
-        end
-      end
-
-      it "should fail if no path is specified" do
-        expect { provider.checkexe('foo') }.to raise_error(ArgumentError, "Could not find command 'foo'")
-      end
-    end
-  end
-
-  describe "#validatecmd" do
-    it "should fail if the command isn't absolute and there is no path" do
-      expect { provider.validatecmd('foo') }.to raise_error(Puppet::Error, /'foo' is not qualified and no path was specified/)
-    end
-
-    it "should not fail if the command is absolute and there is no path" do
-      expect(provider.validatecmd('C:\foo')).to eq(nil)
-    end
-
-    it "should not fail if the command is not absolute and there is a path" do
-      resource[:path] = 'C:\path;C:\another_path'
-
-      expect(provider.validatecmd('foo')).to eq(nil)
-    end
-  end
-end