puppet 6.4.4-universal-darwin → 6.4.5-universal-darwin

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/package_spec.rb

@@ -375,6 +375,11 @@ describe Puppet::Type.type(:package) do
       expect(pkg[:allow_virtual]).to eq true
     end
 
+    it "defaults to false on dpkg provider" do
+      pkg = Puppet::Type.type(:package).new(:name => 'yay', :provider => :dpkg)
+      expect(pkg[:allow_virtual]).to be_nil
+    end
+
     it "defaults to false on platforms that do not support virtual packages" do
       pkg = Puppet::Type.type(:package).new(:name => 'yay', :provider => :apple)
       expect(pkg[:allow_virtual]).to be_nil

data/spec/unit/util/execution_spec.rb

@@ -128,6 +128,13 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? 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, if: !Puppet::Util::Platform.jruby? 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)
@@ -241,22 +338,22 @@ describe Puppet::Util::HttpProxy do
 
   describe '.request_with_redirects' do
     let(:dest) { URI.parse('http://mydomain.com/some/path') }
-    let(:http_ok) { double('http ok', :code => 200, :message => 'HTTP OK') }
 
     it 'generates accept and accept-encoding headers' do
-      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
-      expect_any_instance_of(Net::HTTP).to receive(:get) do |_, _, headers|
-        expect(headers)
-          .to match({'Accept' => '*/*',
-                     'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-                     'User-Agent' => /Puppet/})
-      end.and_return(http_ok)
+      stub_request(:head, dest)
+
+      headers = {
+        'Accept' => '*/*',
+        'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+        'User-Agent' => /Puppet/
+      }
+      stub_request(:get, dest).with(headers: headers)
 
       subject.request_with_redirects(dest, :get, 0)
     end
 
     it 'can return a compressed response body' do
-      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
+      stub_request(:head, dest)
 
       compressed_body = [
         0x1f, 0x8b, 0x08, 0x08, 0xe9, 0x08, 0x7a, 0x5a, 0x00, 0x03,
@@ -264,9 +361,7 @@ describe Puppet::Util::HttpProxy do
         0x00, 0x7a, 0x7a, 0x6f, 0xed, 0x03, 0x00, 0x00, 0x00
       ].pack('C*')
 
-      response = double('http ok', :code => 200, :message => 'HTTP OK', :body => compressed_body)
-      allow(response).to receive(:[]).with('content-encoding').and_return('gzip')
-      expect_any_instance_of(Net::HTTP).to receive(:get).and_return(response)
+      stub_request(:get, dest).to_return(status: 200, body: compressed_body, headers: { 'Content-Encoding' => 'gzip' })
 
       expect(
         uncompress_body(subject.request_with_redirects(dest, :get, 0))
@@ -274,13 +369,14 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'generates accept and accept-encoding headers when a block is provided' do
-      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
-      expect_any_instance_of(Net::HTTP).to receive(:request_get) do |_, _, headers, &block|
-        expect(headers)
-          .to match({'Accept' => '*/*',
-                     'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-                     'User-Agent' => /Puppet/})
-      end.and_return(http_ok)
+      stub_request(:head, dest)
+
+      headers = {
+        'Accept' => '*/*',
+        'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+        'User-Agent' => /Puppet/
+      }
+      stub_request(:get, dest).with(headers: headers)
 
       subject.request_with_redirects(dest, :get, 0) do
         # unused
@@ -288,7 +384,7 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'only makes a single HEAD request' do
-      expect_any_instance_of(Net::HTTP).to receive(:head).with(anything, anything).and_return(http_ok)
+      stub_request(:head, dest)
 
       subject.request_with_redirects(dest, :head, 0)
     end
@@ -296,13 +392,8 @@ describe Puppet::Util::HttpProxy do
     it 'preserves query parameters' do
       url = URI.parse('http://mydomain.com/some/path?foo=bar')
 
-      expect_any_instance_of(Net::HTTP).to receive(:head) do |_method, path, _headers|
-        expect(path).to eq(url)
-      end.and_return(http_ok)
-
-      expect_any_instance_of(Net::HTTP).to receive(:request_get) do |_http, path, _headers, &block|
-        expect(path).to eq(url)
-      end.and_return(http_ok)
+      stub_request(:head, url)
+      stub_request(:get, url)
 
       subject.request_with_redirects(url, :get, 0) do
         # unused

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