puppet 5.5.16-x86-mingw32 → 5.5.21-x86-mingw32

data/spec/unit/util/execution_spec.rb

@@ -128,6 +128,13 @@ describe Puppet::Util::Execution do
 
           call_exec_posix('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)
         end
+
+        it "should not change the current working directory if cwd is unspecified" do
+          expect(Dir).to receive(:chdir).never
+          expect(Kernel).to receive(:exec).with('test command')
+
+          call_exec_posix('test command', {}, @stdin, @stdout, @stderr)
+        end
       end
 
       it "should return the pid of the child process" do
@@ -171,6 +178,15 @@ describe Puppet::Util::Execution do
 
           call_exec_windows('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)
         end
+
+        it "should not change the current working directory if cwd is unspecified" do
+          expect(Dir).to receive(:chdir).never
+          expect(Process).to receive(:create) do |args|
+            expect(args[:cwd]).to be_nil
+          end
+
+          call_exec_windows('test command', {}, @stdin, @stdout, @stderr)
+        end
       end
 
       context 'suppress_window option' do

data/spec/unit/util/http_proxy_spec.rb

@@ -12,6 +12,103 @@ describe Puppet::Util::HttpProxy do
 
   host, port, user, password = 'some.host', 1234, 'user1', 'pAssw0rd'
 
+  def expects_direct_connection_to(http, www)
+    expect(http.address).to eq(www.host)
+    expect(http.port).to eq(www.port)
+
+    expect(http.proxy_address).to be_nil
+    expect(http.proxy_port).to be_nil
+    expect(http.proxy_user).to be_nil
+    expect(http.proxy_pass).to be_nil
+  end
+
+  def expects_proxy_connection_via(http, www, host, port, user, password)
+    expect(http.address).to eq(www.host)
+    expect(http.port).to eq(www.port)
+
+    expect(http.proxy_address).to eq(host)
+    expect(http.proxy_port).to eq(port)
+    expect(http.proxy_user).to eq(user)
+    expect(http.proxy_pass).to eq(password)
+  end
+
+  describe '.proxy' do
+    let(:www) { URI::HTTP.build(host: 'www.example.com', port: 80) }
+
+    it 'uses a proxy' do
+      Puppet[:http_proxy_host] = host
+      Puppet[:http_proxy_port] = port
+      Puppet[:http_proxy_user] = user
+      Puppet[:http_proxy_password] = password
+
+      http = subject.proxy(www)
+      expects_proxy_connection_via(http, www, host, port, user, password)
+    end
+
+    it 'connects directly to the server' do
+      http = subject.proxy(www)
+      expects_direct_connection_to(http, www)
+    end
+
+    context 'when setting no_proxy' do
+      before :each do
+        Puppet[:http_proxy_host] = host
+        Puppet[:http_proxy_port] = port
+      end
+
+      it 'connects directly to the server when HTTP_PROXY environment variable is set, but server matches no_proxy setting' do
+        Puppet[:no_proxy] = www.host
+
+        Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
+          http = subject.proxy(www)
+          expects_direct_connection_to(http, www)
+        end
+      end
+
+      it 'connects directly to the server when no_proxy matches wildcard domain' do
+        Puppet[:no_proxy] = '*.example.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when no_proxy matches dotted domain' do
+        Puppet[:no_proxy] = '.example.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when no_proxy matches a domain suffix like ruby does' do
+        Puppet[:no_proxy] = 'example.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when no_proxy matches a partial suffix like ruby does' do
+        Puppet[:no_proxy] = 'ample.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when it is a subdomain of no_proxy' do
+        Puppet[:no_proxy] = '*.com'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+
+      it 'connects directly to the server when no_proxy is *' do
+        Puppet[:no_proxy] = '*'
+
+        http = subject.proxy(www)
+        expects_direct_connection_to(http, www)
+      end
+    end
+  end
+
   describe ".http_proxy_env" do
     it "should return nil if no environment variables" do
       expect(subject.http_proxy_env).to eq(nil)
@@ -129,9 +226,32 @@ describe Puppet::Util::HttpProxy do
 
   end
 
+  describe ".no_proxy" do
+    no_proxy = '127.0.0.1, localhost'
+    it "should use a no_proxy list if set in environment" do
+      Puppet::Util.withenv('NO_PROXY' => no_proxy) do
+        expect(subject.no_proxy).to eq(no_proxy)
+      end
+    end
+
+    it "should use a no_proxy list if set in config" do
+      Puppet.settings[:no_proxy] = no_proxy
+      expect(subject.no_proxy).to eq(no_proxy)
+    end
+
+    it "should use environment variable before puppet settings" do
+      no_proxy_puppet_setting = '10.0.0.1, localhost'
+      Puppet::Util.withenv('NO_PROXY' => no_proxy) do
+        Puppet.settings[:no_proxy] = no_proxy_puppet_setting
+        expect(subject.no_proxy).to eq(no_proxy)
+      end
+    end
+  end
+
   describe ".no_proxy?" do
     no_proxy = '127.0.0.1, localhost, mydomain.com, *.otherdomain.com, oddport.com:8080, *.otheroddport.com:8080, .anotherdomain.com, .anotheroddport.com:8080'
-    it "should return false if no_proxy does not exist in env" do
+
+    it "should return false if no_proxy does not exist in environment or puppet settings" do
       Puppet::Util.withenv('no_proxy' => nil) do
         dest = 'https://puppetlabs.com'
         expect(subject.no_proxy?(dest)).to be false

data/spec/unit/util/log/destinations_spec.rb

@@ -44,37 +44,13 @@ describe Puppet::Util::Log.desttypes[:file] do
       end
     end
 
-    describe "on POSIX systems", :if => Puppet.features.posix? do
+    describe "on POSIX systems", :unless => Puppet::Util::Platform.windows? do
       describe "with a normal file" do
+        let (:parent) { Pathname.new('/tmp') }
         let (:abspath) { '/tmp/log' }
         let (:relpath) { 'log' }
 
         it_behaves_like "file destination"
-
-        it "logs an error if it can't chown the file owner & group" do
-          expect(File).to receive(:exists?).with(abspath).and_return(false)
-          expect(FileUtils).to receive(:chown).with(Puppet[:user], Puppet[:group], abspath).and_raise(Errno::EPERM)
-          expect(Puppet.features).to receive(:root?).and_return(true)
-          expect(Puppet).to receive(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
-
-          @class.new(abspath)
-        end
-
-        it "doesn't attempt to chown when running as non-root" do
-          expect(File).to receive(:exists?).with(abspath).and_return(false)
-          expect(FileUtils).not_to receive(:chown).with(Puppet[:user], Puppet[:group], abspath)
-          expect(Puppet.features).to receive(:root?).and_return(false)
-
-          @class.new(abspath)
-        end
-
-        it "doesn't attempt to chown when file already exists" do
-          expect(File).to receive(:exists?).with(abspath).and_return(true)
-          expect(FileUtils).not_to receive(:chown).with(Puppet[:user], Puppet[:group], abspath)
-          expect(Puppet.features).to receive(:root?).and_return(true)
-
-          @class.new(abspath)
-        end
       end
 
       describe "with a JSON file" do

data/spec/unit/util/log_spec.rb

@@ -177,118 +177,6 @@ describe Puppet::Util::Log do
 
       expect(logs.collect(&:message)).to include("Inner block", "Outer block")
     end
-
-    it 'includes backtrace for RuntimeError in log message when trace is enabled' do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise RuntimeError, 'Oops'
-        rescue RuntimeError => e
-          Puppet.log_exception(e, :default, :trace => true)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to match('/log_spec.rb')
-      expect(log.backtrace).to be_nil
-    end
-
-    it 'excludes backtrace for RuntimeError in log message when trace is disabled' do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise RuntimeError, 'Oops'
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to_not match('/log_spec.rb')
-      expect(log.backtrace).to be_nil
-    end
-
-    it "backtrace is Array in 'backtrace' and excluded from 'message' when logging ParseErrorWithIssue with trace enabled" do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-        rescue RuntimeError => e
-          Puppet.log_exception(e, :default, :trace => true)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to_not match('/log_spec.rb')
-      expect(log.backtrace).to be_a(Array)
-    end
-
-    it "backtrace is excluded when logging ParseErrorWithIssue with trace disabled" do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to_not match('/log_spec.rb')
-      expect(log.backtrace).to be_nil
-    end
-
-    it 'includes position details for ParseError in log message' do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise Puppet::ParseError.new('Oops', '/tmp/test.pp', 30, 15)
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
-      expect(log.message).to be(log.to_s)
-    end
-
-    it 'excludes position details for ParseErrorWithIssue from log message' do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to_not match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
-      expect(log.to_s).to match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
-      expect(log.issue_code).to eq(:SYNTAX_ERROR)
-      expect(log.file).to eq('/tmp/test.pp')
-      expect(log.line).to eq(30)
-      expect(log.pos).to eq(15)
-    end
   end
 
   describe Puppet::Util::Log::DestConsole do

data/spec/unit/util/logging_spec.rb

@@ -6,6 +6,39 @@ class LoggingTester
   include Puppet::Util::Logging
 end
 
+class PuppetStackCreator
+  def raise_error(exception_class)
+    case exception_class
+    when Puppet::ParseErrorWithIssue
+      raise exception_class.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+    when Puppet::ParseError
+      raise exception_class.new('Oops', '/tmp/test.pp', 30, 15)
+    else
+      raise exception_class.new('Oops')
+    end
+  end
+
+  def call_raiser(exception_class)
+    Puppet::Pops::PuppetStack.stack('/tmp/test2.pp', 20, self, :raise_error, [exception_class])
+  end
+
+  def two_frames_and_a_raise(exception_class)
+    Puppet::Pops::PuppetStack.stack('/tmp/test3.pp', 15, self, :call_raiser, [exception_class])
+  end
+
+  def outer_rescue(exception_class)
+    begin
+      two_frames_and_a_raise(exception_class)
+    rescue Puppet::Error => e
+      Puppet.log_exception(e)
+    end
+  end
+
+  def run(exception_class)
+    Puppet::Pops::PuppetStack.stack('/tmp/test4.pp', 10, self, :outer_rescue, [exception_class])
+  end
+end
+
 describe Puppet::Util::Logging do
   before do
     @logger = LoggingTester.new
@@ -275,6 +308,173 @@ original
 .*2\.rb:2:in `b'
 .*3\.rb:1/)
     end
+
+    describe "when trace is disabled" do
+      it 'excludes backtrace for RuntimeError in log message' do
+        begin
+          raise RuntimeError, 'Oops'
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+        expect(log.message).to_not match('/logging_spec.rb')
+        expect(log.backtrace).to be_nil
+      end
+
+      it "backtrace member is unset when logging ParseErrorWithIssue" do
+        begin
+          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+        expect(log.message).to_not match('/logging_spec.rb')
+        expect(log.backtrace).to be_nil
+      end
+    end
+
+    describe "when trace is enabled" do
+      it 'includes backtrace for RuntimeError in log message when enabled globally' do
+        Puppet[:trace] = true
+        begin
+          raise RuntimeError, 'Oops'
+        rescue RuntimeError => e
+          Puppet.log_exception(e, :default)
+        end
+        Puppet[:trace] = false
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+        expect(log.message).to match('/logging_spec.rb')
+        expect(log.backtrace).to be_nil
+      end
+
+      it 'includes backtrace for RuntimeError in log message when enabled via option' do
+        begin
+          raise RuntimeError, 'Oops'
+        rescue RuntimeError => e
+          Puppet.log_exception(e, :default, :trace => true)
+        end
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+        expect(log.message).to match('/logging_spec.rb')
+        expect(log.backtrace).to be_nil
+      end
+
+
+      it "backtrace member is set when logging ParseErrorWithIssue" do
+        begin
+          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+        rescue RuntimeError => e
+          Puppet.log_exception(e, :default, :trace => true)
+        end
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+        expect(log.message).to_not match('/logging_spec.rb')
+        expect(log.backtrace).to be_a(Array)
+        expect(log.backtrace[0]).to match('/logging_spec.rb')
+      end
+      it "backtrace has interleaved PuppetStack when logging ParseErrorWithIssue" do
+        Puppet[:trace] = true
+        PuppetStackCreator.new.run(Puppet::ParseErrorWithIssue)
+        Puppet[:trace] = false
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+        expect(log.message).to_not match('/logging_spec.rb')
+        expect(log.backtrace[0]).to match('/logging_spec.rb')
+
+        expect(log.backtrace[1]).to match('/tmp/test2.pp:20')
+        puppetstack = log.backtrace.select { |l| l =~ /tmp\/test\d\.pp/ }
+
+        expect(puppetstack.length).to equal 3
+      end
+
+      it "message has interleaved PuppetStack when logging ParseError" do
+        Puppet[:trace] = true
+        PuppetStackCreator.new.run(Puppet::ParseError)
+        Puppet[:trace] = false
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+
+        log_lines = log.message.split("\n")
+        expect(log_lines[1]).to match('/logging_spec.rb')
+        expect(log_lines[2]).to match('/tmp/test2.pp:20')
+        puppetstack = log_lines.select { |l| l =~ /tmp\/test\d\.pp/ }
+
+        expect(puppetstack.length).to equal 3
+      end
+    end
+
+    describe "when trace is disabled but puppet_trace is enabled" do
+      it "includes only PuppetStack as backtrace member with ParseErrorWithIssue" do
+        Puppet[:trace] = false
+        Puppet[:puppet_trace] = true
+        PuppetStackCreator.new.run(Puppet::ParseErrorWithIssue)
+        Puppet[:trace] = false
+        Puppet[:puppet_trace] = false
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+
+        expect(log.backtrace[0]).to match('/tmp/test2.pp:20')
+        expect(log.backtrace.length).to equal 3
+      end
+
+      it "includes only PuppetStack in message with ParseError" do
+        Puppet[:trace] = false
+        Puppet[:puppet_trace] = true
+        PuppetStackCreator.new.run(Puppet::ParseError)
+        Puppet[:trace] = false
+        Puppet[:puppet_trace] = false
+
+        expect(@logs.size).to eq(1)
+        log = @logs[0]
+
+        log_lines = log.message.split("\n")
+        expect(log_lines[1]).to match('/tmp/test2.pp:20')
+        puppetstack = log_lines.select { |l| l =~ /tmp\/test\d\.pp/ }
+
+        expect(puppetstack.length).to equal 3
+      end
+    end
+
+    it 'includes position details for ParseError in log message' do
+      begin
+        raise Puppet::ParseError.new('Oops', '/tmp/test.pp', 30, 15)
+      rescue RuntimeError => e
+        Puppet.log_exception(e)
+      end
+
+      expect(@logs.size).to eq(1)
+      log = @logs[0]
+      expect(log.message).to match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
+      expect(log.message).to be(log.to_s)
+    end
+
+    it 'excludes position details for ParseErrorWithIssue from log message' do
+      begin
+        raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+      rescue RuntimeError => e
+        Puppet.log_exception(e)
+      end
+
+      expect(@logs.size).to eq(1)
+      log = @logs[0]
+      expect(log.message).to_not match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
+      expect(log.to_s).to match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
+      expect(log.issue_code).to eq(:SYNTAX_ERROR)
+      expect(log.file).to eq('/tmp/test.pp')
+      expect(log.line).to eq(30)
+      expect(log.pos).to eq(15)
+    end
   end
 
   describe 'when Facter' do