puppet 6.4.5-universal-darwin → 6.5.0-universal-darwin

data/spec/unit/transaction_spec.rb

@@ -3,7 +3,6 @@ require 'matchers/include_in_order'
 require 'puppet_spec/compiler'
 
 require 'puppet/transaction'
-require 'puppet/type/exec'
 require 'puppet/type/notify'
 require 'fileutils'
 
@@ -780,24 +779,6 @@ describe Puppet::Transaction do
 
       transaction.evaluate
     end
-
-    it "should call Selinux.matchpathcon_fini in case Selinux is enabled ", :if => Puppet.features.posix? do
-      unless defined?(Selinux)
-        module Selinux
-          def self.is_selinux_enabled
-            true
-          end
-        end
-      end
-
-      resource = Puppet::Type.type(:file).new(:path => make_absolute("/tmp/foo"))
-      transaction = transaction_with_resource(resource)
-
-      expect(Selinux).to receive(:matchpathcon_fini)
-      expect(Puppet::Util::SELinux).to receive(:selinux_support?).and_return(true)
-
-      transaction.evaluate
-    end
   end
 
   describe 'when checking application run state' do
@@ -968,51 +949,6 @@ describe Puppet::Transaction do
       expect(times_send_log_with_skipping_called).to eq(3)
     end
   end
-
-  describe "failed dependency is depended on multiple times" do
-    it "notifies and warns the failed class dependency once" do
-      Puppet.settings[:merge_dependency_warnings] = true
-
-      command_string = File.expand_path('/my/command')
-      allow(Puppet::Util::Execution).to receive(:execute).with([command_string]).and_raise(Puppet::ExecutionFailure, "Failed")
-
-      # Exec['exec1'] is outside of a class, so it's warning is not subject to being coalesced.
-      times_send_log_with_skipping_called = 0
-      allow_any_instance_of(Puppet::Type::Exec).to receive(:send_log) {times_send_log_with_skipping_called += 1; nil}.with(:warning, "Skipping because of failed dependencies")
-
-      # Class['declared_class'] depends upon Class['required_class'] which contains a resource with a failure.
-      times_send_log_with_class_dependency_called = 0
-      allow_any_instance_of(Puppet::Type).to receive(:send_log) {times_send_log_with_class_dependency_called += 1; nil}.with(:notice, "Class dependency Exec[exec2] has failures: true")
-      times_send_log_with_class_skipping_called = 0
-      allow_any_instance_of(Puppet::Type).to receive(:send_log) {times_send_log_with_class_skipping_called += 1; nil}.with(:warning, "Skipping resources in class because of failed class dependencies")
-
-      apply_compiled_manifest(<<-MANIFEST)
-        class required_class {
-          exec { 'exec2':
-            command => '#{command_string}'
-          }
-        }
-        class declared_class {
-          require required_class
-          exec { 'exec3':
-            command => '#{command_string}'
-          }
-          exec { 'exec4':
-            command => '#{command_string}'
-          }
-        }
-        exec { 'exec1':
-          command => '#{command_string}',
-          require => Exec['exec2']
-        }
-        include declared_class
-      MANIFEST
-
-      expect(times_send_log_with_skipping_called).to eq(1)
-      expect(times_send_log_with_class_dependency_called).to eq(1)
-      expect(times_send_log_with_class_skipping_called).to eq(1)
-    end
-  end
 end
 
 describe Puppet::Transaction, " when determining tags" do

data/spec/unit/type/exec_spec.rb

@@ -150,13 +150,16 @@ RSpec.describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should redact the sensitive command on failure" do
+      it "should redact the 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/)
 
-        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/))
+        output.split("\n").each do |line|
+          log = @logs.shift
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
+        end
       end
 
       it "should log the output on failure when returns is specified as an array" do
@@ -174,7 +177,7 @@ RSpec.describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should redact the sensitive command on failure when returns is specified as an array" do
+      it "should redact the command on failure when returns is specified as an array" do
         output = "output1\noutput2\n"
 
         expect {
@@ -182,8 +185,11 @@ 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/)
 
-        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/))
+        output.split("\n").each do |line|
+          log = @logs.shift
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
+        end
       end
 
       it "shouldn't log the output on success" do
@@ -765,15 +771,6 @@ RSpec.describe Puppet::Type.type(:exec) do
           expect(@test.check_all_attributes).to eq(true)
           expect(@logs.shift.message).to eq("test output")
         end
-
-        it "should not emit output to debug if sensitive is true" do
-          Puppet::Util::Log.level = :debug
-          @test[param] = @fail
-          allow(@test.parameters[param]).to receive(:sensitive).and_return(true)
-          expect(@test.check_all_attributes).to eq(true)
-          expect(@logs).not_to include(an_object_having_attributes(level: :debug, message: "test output"))
-          expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        end
       end
     end
   end

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

@@ -200,21 +200,15 @@ 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")
-              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).to receive(:diff).and_return("my diff").once
+              expect(content).to receive(:debug).with("\nmy diff").once
               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]")
+              expect(content).to receive(:debug).with("[diff redacted]").once
               expect(content).not_to be_safe_insync("other content")
             end
           end

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

@@ -34,11 +34,11 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
     it "should fail if the set values are not URLs" do
       expect(URI).to receive(:parse).with('foo').and_raise(RuntimeError)
 
-      expect { resource[:source] = %w{foo} }.to raise_error(Puppet::Error)
+      expect(lambda { resource[:source] = %w{foo} }).to raise_error(Puppet::Error)
     end
 
     it "should fail if the URI is not a local file, file URI, or puppet URI" do
-      expect { resource[:source] = %w{ftp://foo/bar} }.to raise_error(Puppet::Error, /Cannot use URLs of type 'ftp' as source for fileserving/)
+      expect(lambda { resource[:source] = %w{ftp://foo/bar} }).to raise_error(Puppet::Error, /Cannot use URLs of type 'ftp' as source for fileserving/)
     end
 
     it "should strip trailing forward slashes", :unless => Puppet::Util::Platform.windows? do
@@ -61,11 +61,11 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
     end
 
     it "should reject relative URI sources" do
-      expect { resource[:source] = 'foo/bar' }.to raise_error(Puppet::Error)
+      expect(lambda { resource[:source] = 'foo/bar' }).to raise_error(Puppet::Error)
     end
 
     it "should reject opaque sources" do
-      expect { resource[:source] = 'mailto:foo@com' }.to raise_error(Puppet::Error)
+      expect(lambda { resource[:source] = 'mailto:foo@com' }).to raise_error(Puppet::Error)
     end
 
     it "should accept URI authority component" do

data/spec/unit/type/file_spec.rb

@@ -477,9 +477,6 @@ 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
@@ -488,9 +485,8 @@ 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(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([])
+        allow(file).to receive(:recurse_local).and_return(:foo => "bar")
+        expect(file).to receive(:recurse_remote).with(:foo => "bar").and_return([])
         file.recurse
       end
     end
@@ -498,9 +494,8 @@ 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(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([])
+        allow(file).to receive(:recurse_local).and_return(:foo => "bar")
+        expect(file).to receive(:recurse_link).with(:foo => "bar").and_return([])
         file.recurse
       end
     end
@@ -1152,13 +1147,13 @@ describe Puppet::Type.type(:file) do
 
         it "should convert symbolic mode to int" do
           file[:mode] = 'oga=r'
-          expect(Puppet::Util).to receive(:replace_file).with(file[:path], 0444)
+          expect(Puppet::Util).to receive(:replace_file).with(file[:path], 0444, { :staging_location => nil, :validate_callback => nil })
           file.write
         end
 
         it "should support int modes" do
           file[:mode] = '0444'
-          expect(Puppet::Util).to receive(:replace_file).with(file[:path], 0444)
+          expect(Puppet::Util).to receive(:replace_file).with(file[:path], 0444, { :staging_location => nil, :validate_callback => nil })
           file.write
         end
       end
@@ -1259,6 +1254,15 @@ describe Puppet::Type.type(:file) do
     it "should be false if the file has neither content nor source" do
       expect(file.send(:write_temporary_file?)).to be_falsey
     end
+
+    context "and staging_location is provided" do
+      it "should write the file first to the staging location" do
+        file[:content] = 'some content'
+        file[:staging_location] = Dir.tmpdir()
+        expect(Puppet::Util).to receive(:replace_file).with(file[:path], nil, { staging_location: Dir.tmpdir(), validate_callback: nil })
+        file.write
+      end
+    end
   end
 
   describe "#property_fix" do

data/spec/unit/type/package_spec.rb

@@ -375,11 +375,6 @@ 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/type/schedule_spec.rb

@@ -446,9 +446,7 @@ describe Puppet::Type.type(:schedule) do
 
     it "should fail if the periodmatch is 'number'" do
       @schedule[:periodmatch] = :number
-      expect {
-        @schedule[:repeat] = 2
-      }.to raise_error(Puppet::Error)
+      expect(proc { @schedule[:repeat] = 2 }).to raise_error(Puppet::Error)
     end
 
     it "should match if the previous run was further away than the distance divided by the repeat" do

data/spec/unit/type/service_spec.rb

@@ -93,13 +93,6 @@ describe test_title, "when validating attribute values" do
       expect(srv.should(:enable)).to eq(:manual)
     end
 
-    it "should support :delayed as a value on Windows" do
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
-
-      srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :delayed)
-      expect(srv.should(:enable)).to eq(:delayed)
-    end
-
     it "should not support :manual as a value when not on Windows" do
       allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
 
@@ -108,15 +101,6 @@ describe test_title, "when validating attribute values" do
         /Setting enable to manual is only supported on Microsoft Windows\./
       )
     end
-
-    it "should not support :delayed as a value when not on Windows" do
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-
-      expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :delayed) }.to raise_error(
-        Puppet::Error,
-        /Setting enable to delayed is only supported on Microsoft Windows\./
-      )
-    end
   end
 
   describe "the timeout parameter" do

data/spec/unit/util/execution_spec.rb

@@ -128,13 +128,6 @@ 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
@@ -178,15 +171,6 @@ 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,103 +12,6 @@ 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)
@@ -226,32 +129,9 @@ 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 environment or puppet settings" do
+    it "should return false if no_proxy does not exist in env" do
       Puppet::Util.withenv('no_proxy' => nil) do
         dest = 'https://puppetlabs.com'
         expect(subject.no_proxy?(dest)).to be false
@@ -338,22 +218,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
-      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)
+      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)
 
       subject.request_with_redirects(dest, :get, 0)
     end
 
     it 'can return a compressed response body' do
-      stub_request(:head, dest)
+      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
 
       compressed_body = [
         0x1f, 0x8b, 0x08, 0x08, 0xe9, 0x08, 0x7a, 0x5a, 0x00, 0x03,
@@ -361,7 +241,9 @@ describe Puppet::Util::HttpProxy do
         0x00, 0x7a, 0x7a, 0x6f, 0xed, 0x03, 0x00, 0x00, 0x00
       ].pack('C*')
 
-      stub_request(:get, dest).to_return(status: 200, body: compressed_body, headers: { 'Content-Encoding' => 'gzip' })
+      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)
 
       expect(
         uncompress_body(subject.request_with_redirects(dest, :get, 0))
@@ -369,14 +251,13 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'generates accept and accept-encoding headers when a block is provided' do
-      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)
+      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)
 
       subject.request_with_redirects(dest, :get, 0) do
         # unused
@@ -384,20 +265,9 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'only makes a single HEAD request' do
-      stub_request(:head, dest)
+      expect_any_instance_of(Net::HTTP).to receive(:head).with(anything, anything).and_return(http_ok)
 
       subject.request_with_redirects(dest, :head, 0)
     end
-
-    it 'preserves query parameters' do
-      url = URI.parse('http://mydomain.com/some/path?foo=bar')
-
-      stub_request(:head, url)
-      stub_request(:get, url)
-
-      subject.request_with_redirects(url, :get, 0) do
-        # unused
-      end
-    end
   end
 end