puppet 5.5.17-x64-mingw32 → 5.5.18-x64-mingw32

data/spec/unit/type/exec_spec.rb

@@ -150,16 +150,13 @@ RSpec.describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should redact the command on failure" do
+      it "should redact the sensitive command on failure" do
         output = "output1\noutput2\n"
         expect { exec_tester('false', 1, :output => output, :logoutput => :on_failure, :sensitive_parameters => [:command]).refresh }.
             to raise_error(Puppet::Error, /^\[command redacted\] returned 1 instead of/)
 
-        output.split("\n").each do |line|
-          log = @logs.shift
-          expect(log.level).to eq(:err)
-          expect(log.message).to eq(line)
-        end
+        expect(@logs).to include(an_object_having_attributes(level: :err, message: '[output redacted]'))
+        expect(@logs).to_not include(an_object_having_attributes(message: /output1|output2/))
       end
 
       it "should log the output on failure when returns is specified as an array" do
@@ -177,7 +174,7 @@ RSpec.describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should redact the command on failure when returns is specified as an array" do
+      it "should redact the sensitive command on failure when returns is specified as an array" do
         output = "output1\noutput2\n"
 
         expect {
@@ -185,11 +182,8 @@ RSpec.describe Puppet::Type.type(:exec) do
                       :logoutput => :on_failure, :sensitive_parameters => [:command]).refresh
         }.to raise_error(Puppet::Error, /^\[command redacted\] returned 1 instead of/)
 
-        output.split("\n").each do |line|
-          log = @logs.shift
-          expect(log.level).to eq(:err)
-          expect(log.message).to eq(line)
-        end
+        expect(@logs).to include(an_object_having_attributes(level: :err, message: '[output redacted]'))
+        expect(@logs).to_not include(an_object_having_attributes(message: /output1|output2/))
       end
 
       it "shouldn't log the output on success" do

data/spec/unit/type/file/content_spec.rb

@@ -200,15 +200,21 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
             end
 
             it "prints the diff" do
-              expect(content).to receive(:diff).and_return("my diff").once
-              expect(content).to receive(:debug).with("\nmy diff").once
+              expect(content).to receive(:diff).and_return("my diff")
+              expect(content).to receive(:debug).with("\nmy diff")
+              expect(content).not_to be_safe_insync("other content")
+            end
+
+            it "prints binary file notice if diff is not valid encoding" do
+              expect(content).to receive(:diff).and_return("\xc7\xd1\xfc\x84")
+              expect(content).to receive(:debug).with(/\nBinary files #{filename} and .* differ/)
               expect(content).not_to be_safe_insync("other content")
             end
 
             it "redacts the diff when the property is sensitive" do
               content.sensitive = true
               expect(content).not_to receive(:diff)
-              expect(content).to receive(:debug).with("[diff redacted]").once
+              expect(content).to receive(:debug).with("[diff redacted]")
               expect(content).not_to be_safe_insync("other content")
             end
           end

data/spec/unit/type/file_spec.rb

@@ -477,6 +477,9 @@ describe Puppet::Type.type(:file) do
   end
 
   describe "#recurse" do
+    let(:name) { 'bar' }
+    let(:child) { double('puppet_type_file') }
+
     before do
       file[:recurse] = true
       @metadata = Puppet::FileServing::Metadata
@@ -485,8 +488,9 @@ describe Puppet::Type.type(:file) do
     describe "and a source is set" do
       it "should pass the already-discovered resources to recurse_remote" do
         file[:source] = File.expand_path(__FILE__)
-        allow(file).to receive(:recurse_local).and_return(:foo => "bar")
-        expect(file).to receive(:recurse_remote).with(:foo => "bar").and_return([])
+        allow(child).to receive(:[]).with(:path).and_return(name)
+        allow(file).to receive(:recurse_local).and_return(name => child)
+        expect(file).to receive(:recurse_remote).with(name => child).and_return([])
         file.recurse
       end
     end
@@ -494,8 +498,9 @@ describe Puppet::Type.type(:file) do
     describe "and a target is set" do
       it "should use recurse_link" do
         file[:target] = File.expand_path(__FILE__)
-        allow(file).to receive(:recurse_local).and_return(:foo => "bar")
-        expect(file).to receive(:recurse_link).with(:foo => "bar").and_return([])
+        allow(child).to receive(:[]).with(:path).and_return(name)
+        allow(file).to receive(:recurse_local).and_return(name => child)
+        expect(file).to receive(:recurse_link).with(name => child).and_return([])
         file.recurse
       end
     end

data/spec/unit/type/selboolean_spec.rb

@@ -24,12 +24,10 @@ describe Puppet::Type.type(:selboolean), "when validating values" do
     allow(@provider_class).to receive(:new).and_return(@provider)
   end
 
-  it "should support :on as a value to :value" do
-    Puppet::Type.type(:selboolean).new(:name => "yay", :value => :on)
-  end
-
-  it "should support :off as a value to :value" do
-    Puppet::Type.type(:selboolean).new(:name => "yay", :value => :off)
+  [:on, :off, :true, :false, true, false].each do |val|
+    it "should support #{val.inspect} as a value to :value" do
+      Puppet::Type.type(:selboolean).new(:name => "yay", :value => val)
+    end
   end
 
   it "should support :true as a value to :persistent" do

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)

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

@@ -46,13 +46,15 @@ describe Puppet::Util::Log.desttypes[:file] do
 
     describe "on POSIX systems", :if => Puppet.features.posix? 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)
+          allow(File).to receive(:exist?).with(parent).and_return(true)
+          expect(File).to receive(:exist?).with(Pathname.new(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}")
@@ -61,7 +63,8 @@ describe Puppet::Util::Log.desttypes[:file] do
         end
 
         it "doesn't attempt to chown when running as non-root" do
-          expect(File).to receive(:exists?).with(abspath).and_return(false)
+          allow(File).to receive(:exist?).with(parent).and_return(true)
+          expect(File).to receive(:exist?).with(Pathname.new(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)
 
@@ -69,7 +72,8 @@ describe Puppet::Util::Log.desttypes[:file] do
         end
 
         it "doesn't attempt to chown when file already exists" do
-          expect(File).to receive(:exists?).with(abspath).and_return(true)
+          allow(File).to receive(:exist?).with(parent).and_return(true)
+          expect(File).to receive(:exist?).with(Pathname.new(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)
 

data/spec/unit/util/log_spec.rb

@@ -177,144 +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 option is passed' 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
-
-    context "global options" do
-      around :each do |example|
-        Puppet[:trace] = true
-        example.run
-        Puppet[:trace] = false
-      end
-
-      it 'includes backtrace for RuntimeError in log message when trace is enabled globally' 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)
-          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
-    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