puppet 7.9.0-x64-mingw32 → 7.12.1-x64-mingw32

data/spec/unit/indirector/catalog/rest_spec.rb

@@ -33,6 +33,14 @@ describe Puppet::Resource::Catalog::Rest do
     described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
   end
 
+  it "passes 'check_environment'" do
+    stub_request(:post, uri)
+      .with(body: hash_including('check_environment' => 'true'))
+      .to_return(**catalog_response(catalog))
+
+    described_class.indirection.find(certname, check_environment: true)
+  end
+
   it 'constructs a catalog environment_instance' do
     env = Puppet::Node::Environment.remote('outerspace')
     catalog = Puppet::Resource::Catalog.new(certname, env)

data/spec/unit/indirector/indirection_spec.rb

@@ -499,7 +499,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should return the result of saving to the terminus" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false)
+          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -509,7 +509,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should use a request to save the object to the cache" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false)
+          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -519,7 +519,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should not save to the cache if the normal save fails" do
-          request = double('request', :instance => @instance, :node => nil)
+          request = double('request', :instance => @instance, :node => nil, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -534,6 +534,13 @@ describe Puppet::Indirector::Indirection do
 
           @indirection.save(@instance, '/my/key', :ignore_cache_save => true)
         end
+
+        it "should only save to the cache if the request specifies not to use the terminus" do
+          expect(@terminus).not_to receive(:save)
+          expect(@cache).to receive(:save)
+
+          @indirection.save(@instance, "/my/key", :ignore_terminus => true)
+        end
       end
     end
 

data/spec/unit/interface/action_spec.rb

@@ -537,15 +537,6 @@ describe Puppet::Interface::Action do
     end
   end
 
-  context "#when_rendering" do
-    it "should fail if no type is given when_rendering"
-    it "should accept a when_rendering block"
-    it "should accept multiple when_rendering blocks"
-    it "should fail if when_rendering gets a non-symbol identifier"
-    it "should fail if a second block is given for the same type"
-    it "should return the block if asked"
-  end
-
   context "#validate_and_clean" do
     subject do
       Puppet::Interface.new(:validate_args, '1.0.0') do

data/spec/unit/module_spec.rb

@@ -567,6 +567,20 @@ describe Puppet::Module do
       expect(mod.task_file(task_exe)).to eq("#{mod.path}/tasks/#{task_exe}")
     end
 
+    it "should list files from the scripts directory if required by the task" do
+      mod         = 'loads_scripts'
+      task_dep    = 'myscript.sh'
+      script_ref  = "#{mod}/scripts/#{task_dep}"
+      task_json   = JSON.generate({'files' => [script_ref]})
+      task        = [['task', { name: 'task.json', content: task_json }]]
+      mod         = PuppetSpec::Modules.create(mod, @modpath, {:environment => env,
+                                                       :scripts     => [task_dep],
+                                                       :tasks       => task})
+
+      expect(mod.tasks.first.files).to include({'name' => script_ref,
+                                                'path' => /#{script_ref}/})
+    end
+
     it "should return nil when asked for an individual task file if it does not exist" do
       mod = PuppetSpec::Modules.create('task_file_neg', @modpath, {:environment => env,
                                                                    :tasks => []})

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -284,18 +284,45 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
           expect(subject).to include :result => :failure
         end
 
-        it 'prints a detailed error containing the modules that would not be satisfied' do
-          graph = double(SemanticPuppet::Dependency::Graph, :modules => ['pmtacceptance-mysql'])
-          exception = SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph)
-          allow(exception).to receive(:respond_to?).and_return(true)
-          allow(exception).to receive(:unsatisfied).and_return('pmtacceptance-mysql')
-          allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(exception)
-
-          expect(subject[:error]).to include(:multiline)
-          expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
-          expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
-          expect(subject[:error][:multiline]).to include("pmtacceptance-keystone, expects 'pmtacceptance-mysql': >=0.6.1 <1.0.0")
-          expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+        context 'with unsatisfiable dependencies' do
+          let(:graph) { double(SemanticPuppet::Dependency::Graph, :modules => ['pmtacceptance-mysql']) }
+          let(:exception) { SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph, constraint) }
+
+          before do
+            allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(exception)
+          end
+
+          context 'with known constraint' do
+            let(:constraint) { 'pmtacceptance-mysql' }
+
+            it 'prints a detailed error containing the modules that would not be satisfied' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+              expect(subject[:error][:multiline]).to include("pmtacceptance-keystone, expects 'pmtacceptance-mysql': >=0.6.1 <1.0.0")
+              expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+            end
+          end
+
+          context 'with missing constraint' do
+            let(:constraint) { nil }
+
+            it 'prints the generic error message' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy all dependencies")
+            end
+          end
+
+          context 'with unknown constraint' do
+            let(:constraint) { 'another' }
+
+            it 'prints the generic error message' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy all dependencies")
+            end
+          end
         end
 
         context 'with --ignore-dependencies' do

data/spec/unit/network/formats_spec.rb

@@ -368,6 +368,12 @@ describe "Puppet Network Format" do
       expect(json.render_multiple(instances)).to eq([{"string" => "foo"}].to_json)
     end
 
+    it "should render multiple instances as a JSON array of hashes when multi_json is not present" do
+      hide_const("MultiJson") if defined?(MultiJson)
+      instances = [FormatsTest.new("foo")]
+      expect(json.render_multiple(instances)).to eq([{"string" => "foo"}].to_json)
+    end
+
     it "should intern an instance from a JSON hash" do
       text = Puppet::Util::Json.dump({"string" => "parsed_json"})
       instance = json.intern(FormatsTest, text)

data/spec/unit/pops/parser/parse_containers_spec.rb

@@ -95,18 +95,7 @@ describe "egrammar parsing containers" do
         expect(dump(parse("class foo::default {}"))).to eq("(class foo::default ())")
       end
 
-      it "class class inherits default {} # inherits default", :broken => true do
-        expect {
-          parse("class class inherits default {}")
-        }.to raise_error(/not a valid classname/)
-      end
-
       it "class class inherits default {} # inherits default" do
-        # TODO: See previous test marked as :broken=>true, it is actually this test (result) that is wacky,
-        # this because a class is named at parse time (since class evaluation is lazy, the model must have the
-        # full class name for nested classes - only, it gets this wrong when a class is named "class" - or at least
-        # I think it is wrong.)
-        #
         expect { parse("class class inherits default {}") }.to raise_error(/'class' keyword not allowed at this location/)
       end
 

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -559,6 +559,29 @@ module Serialization
         expect(warnings).to eql(["['key'] contains the special value default. It will be converted to the String 'default'"])
       end
     end
+    context 'and force_symbol set to true' do
+      let(:to_converter) { ToDataConverter.new(:rich_data => false, :force_symbol => true) }
+
+      it 'A Hash with Symbol values is converted to hash with Symbol values' do
+        val = { 'one' => :one, 'two' => :two }
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+
+          # write and read methods does not work here as we cannot force Symbols in Json.
+          # and a hash with symbol values cannot be an instance of Types::TypeFactory.data.
+          # Using YAML for this instead
+          io.reopen
+          value = to_converter.convert(val)
+          io << [value].to_yaml
+          io.rewind
+
+          val2 = from_converter.convert(YAML::load(io.read)[0])
+
+          expect(val2).to be_a(Hash)
+          expect(val2).to eql({ 'one' => :one, 'two' => :two })
+        end
+        expect(warnings).to be_empty
+      end
+    end
   end
 
   context 'with rich_data is set to true' do
@@ -632,6 +655,41 @@ module Serialization
       end.to raise_error(/Cannot create a Pcore::TimestampType from a Integer/)
     end
   end
+
+  context 'when data is unknown' do
+    let(:to_converter) { ToDataConverter.new(:message_prefix => 'Test Hash') }
+    let(:logs) { [] }
+    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+    let(:val) { Class.new }
+
+    context 'and :silence_warnings undefined or set to false' do
+      it 'convert the unknown data to string with warnings' do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          write(val)
+          val2 = read
+          expect(val2).to be_a(String)
+          expect(val2).to match(/Class/)
+        end
+        expect(warnings).to eql([
+          "Test Hash contains a #{val.class} value. It will be converted to the String '#{val.to_s}'"])
+      end
+    end
+
+    context 'and :silence_warnings undefined or set to true' do
+      let(:to_converter) { ToDataConverter.new(:message_prefix => 'Test Hash', :silence_warnings => true) }
+
+      it 'convert the unknown data to string without warnings if silence_warnings set to true' do
+        val = Class.new
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          write(val)
+          val2 = read
+          expect(val2).to be_a(String)
+          expect(val2).to match(/Class/)
+        end
+        expect(warnings).to be_empty
+      end
+    end
+  end
 end
 end
 end

data/spec/unit/pops/serialization/to_stringified_spec.rb

@@ -154,4 +154,9 @@ describe 'ToStringifiedConverter' do
     unassigned = [243, 176, 128, 128].pack("C*").force_encoding(Encoding::UTF_8) 
     expect(transform(unassigned)).to eq("󰀀")
   end
+
+  it 'converts ProcessOutput objects to string' do
+    object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
+    expect(transform(object)).to be_instance_of(String)
+  end
 end

data/spec/unit/pops/types/type_calculator_spec.rb

@@ -1980,6 +1980,12 @@ describe 'The type calculator' do
       expect(calculator.instance?(tuple, [1, 'a', 1])).to          eq(false)
     end
 
+    it 'should not consider ProcessOutput objects as instanceof PScalarDataType' do
+      object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
+      
+      expect(calculator.instance?(PScalarDataType::DEFAULT, object)).to eq(false)
+    end
+
     context 'and t is Struct' do
       it 'should consider hash[cont] as instance of Struct[cont-t]' do
         struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>Float})

data/spec/unit/provider/package/gem_spec.rb

@@ -476,7 +476,7 @@ context Puppet::Type.type(:package).provider(:gem) do
     end
 
     context 'when is defaultfor' do
-      let(:os) { Facter.value(:operatingsystem) }
+      let(:os) { Puppet.runtime[:facter].value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/pip2_spec.rb

@@ -26,7 +26,7 @@ describe Puppet::Type.type(:package).provider(:pip2) do
     end
 
     context 'when is defaultfor' do
-      let(:os) { Facter.value(:operatingsystem) }
+      let(:os) { Puppet.runtime[:facter].value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/pip3_spec.rb

@@ -26,7 +26,7 @@ describe Puppet::Type.type(:package).provider(:pip3) do
     end
 
     context 'when is defaultfor' do
-      let(:os) { Facter.value(:operatingsystem) }
+      let(:os) { Puppet.runtime[:facter].value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/pip_spec.rb

@@ -493,7 +493,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     context 'when is defaultfor' do
-      let(:os) { Facter.value(:operatingsystem) }
+      let(:os) { Puppet.runtime[:facter].value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/pkg_spec.rb

@@ -342,14 +342,17 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             resource[:ensure] = '1.0-0.151006'
             is = :absent
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
-            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(provider).to receive(:properties).and_return({:mark => :hold}).exactly(3).times
+
+            expect(described_class).to receive(:pkg)
+              .with(:freeze, 'dummy')
             expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
               .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            expect(provider).to receive(:unhold).with(no_args)
+            expect(provider).to receive(:unhold).with(no_args).twice
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
@@ -361,12 +364,17 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             resource[:ensure] = '1.0-0.151006'
             is = '1.0,5.11-0.151006:20140219T191204Z'
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
-            expect(provider).to receive(:properties).and_return({:mark => :hold})
-            expect(described_class).to receive(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').and_return(File.read(my_fixture('dummy_implicit_version')))
+            expect(provider).to receive(:properties).and_return({:mark => :hold}).exactly(3).times
+
+            expect(described_class).to receive(:pkg)
+              .with(:freeze, 'dummy')
+            expect(described_class).to receive(:pkg)
+              .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
+              .and_return(File.read(my_fixture('dummy_implicit_version')))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            expect(provider).to receive(:unhold).with(no_args)
+            expect(provider).to receive(:unhold).with(no_args).twice
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
@@ -381,6 +389,9 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
               .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 4))
@@ -395,11 +406,29 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
               .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.insync?(is)
           end
+
+          it "should try 5 times to install and fail when all tries failed" do
+            allow_any_instance_of(Kernel).to receive(:sleep)
+
+            expect(provider).to receive(:query).and_return({:ensure => :absent})
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(provider).to receive(:unhold)
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 7))
+              .exactly(5).times
+            expect {
+              provider.update
+            }.to raise_error(Puppet::Error, /Pkg could not install dummy after 5 tries. Aborting run/)
+          end
         end
       end
     end

data/spec/unit/provider/package/puppet_gem_spec.rb

@@ -118,7 +118,7 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
     end
 
     context 'when is defaultfor' do
-      let(:os) { Facter.value(:operatingsystem) }
+      let(:os) { Puppet.runtime[:facter].value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/puppetserver_gem_spec.rb

@@ -127,7 +127,7 @@ describe Puppet::Type.type(:package).provider(:puppetserver_gem) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
+      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/service/launchd_spec.rb

@@ -325,6 +325,7 @@ describe 'Puppet::Type::Service::Provider::Launchd',
           'LimitLoadToSessionType' => 'Aqua'
         }
       end
+      let(:plist_without_label_not_hash) { 'just a string' }
       let(:busted_plist_path) { '/Library/LaunchAgents/org.busted.plist' }
       let(:binary_plist_path) { '/Library/LaunchAgents/org.binary.plist' }
 
@@ -336,6 +337,16 @@ describe 'Puppet::Type::Service::Provider::Launchd',
         expect(Puppet).to receive(:debug).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
         provider.make_label_to_path_map
       end
+
+      it "it should warn that the malformed plist in question is being skipped" do
+        expect(provider).to receive(:launchd_paths).and_return(['/Library/LaunchAgents'])
+        expect(provider).to receive(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').and_return([busted_plist_path])
+        expect(plistlib).to receive(:read_plist_file).with(busted_plist_path).and_return(plist_without_label_not_hash)
+        expect(Puppet).to receive(:debug).with("Reading launchd plist #{busted_plist_path}")
+        expect(Puppet).to receive(:debug).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
+        provider.make_label_to_path_map
+      end
+
     end
 
     it "should return the cached value when available" do

data/spec/unit/provider/service/systemd_spec.rb

@@ -29,7 +29,7 @@ describe 'Puppet::Type::Service::Provider::Systemd',
     end
   end
 
-  [7, 8].each do |ver|
+  [7, 8, 9].each do |ver|
     it "should be the default provider on rhel#{ver}" do
       allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
       allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)

data/spec/unit/provider/user/aix_spec.rb

@@ -217,4 +217,104 @@ describe 'Puppet::Type::User::Provider::Aix' do
       provider.create
     end
   end
+
+  describe '#list_all_homes' do
+    it "should return empty array and output debug on failure" do
+      allow(Puppet::Util::Execution).to receive(:execute).and_raise(Puppet::ExecutionFailure, 'Execution failed')
+      expect(Puppet).to receive(:debug).with('Could not list home of all users: Execution failed')
+      expect(provider.list_all_homes).to eql({})
+    end
+  end
+
+  describe '#delete' do
+    before(:each) do
+      allow(File).to receive(:realpath).and_call_original
+      allow(FileUtils).to receive(:remove_entry_secure).and_call_original
+
+      allow(provider.resource).to receive(:should).with(anything).and_return(nil)
+      allow(provider).to receive(:home).and_return(Dir.tmpdir)
+      allow(provider).to receive(:execute).and_return(nil)
+      allow(provider).to receive(:object_info).and_return(nil)
+      allow(FileUtils).to receive(:remove_entry_secure).with(Dir.tmpdir, true).and_return(nil)
+    end
+
+    context 'with managehome true' do
+      before(:each) do
+        allow(provider.resource).to receive(:managehome?).and_return(true)
+        allow(provider).to receive(:list_all_homes).and_return([])
+      end
+
+      it 'should delete the user without error' do
+        expect{ provider.delete }.not_to raise_error
+      end
+
+      it "should not remove home when relative" do
+        allow(provider).to receive(:home).and_return('relative_path')
+
+        expect(Puppet).to receive(:debug).with(/Please make sure the path is not relative, symlink or '\/'./)
+        provider.delete
+      end
+
+      it "should not remove home when '/'" do
+        allow(provider).to receive(:home).and_return('/')
+
+        expect(Puppet).to receive(:debug).with(/Please make sure the path is not relative, symlink or '\/'./)
+        provider.delete
+      end
+
+      it "should not remove home when symlink" do
+        allow(Puppet::FileSystem).to receive(:symlink?).with(Dir.tmpdir).and_return(true)
+
+        expect(Puppet).to receive(:debug).with(/Please make sure the path is not relative, symlink or '\/'./)
+        provider.delete
+      end
+
+      it "should not remove home when other users would be affected" do
+        allow(provider).to receive(:home).and_return('/special')
+        allow(File).to receive(:realpath).with('/special').and_return('/special')
+        allow(Puppet::Util).to receive(:absolute_path?).with('/special').and_return(true)
+        allow(provider).to receive(:list_all_homes).and_return([{:name => 'other_user', :home => '/special/other_user'}])
+
+        expect(Puppet).to receive(:debug).with(/it would remove the home directory '\/special\/other_user' of user 'other_user' also./)
+        provider.delete
+      end
+
+      it 'should remove homedir' do
+        expect(FileUtils).to receive(:remove_entry_secure).with(Dir.tmpdir, true)
+        provider.delete
+      end
+    end
+
+    context 'with managehome false' do
+      before(:each) do
+        allow(provider.resource).to receive(:managehome?).and_return(false)
+      end
+
+      it 'should delete the user without error' do
+        expect{ provider.delete }.not_to raise_error
+      end
+
+      it 'should not remove homedir' do
+        expect(FileUtils).not_to receive(:remove_entry_secure).with(Dir.tmpdir, true)
+      end
+
+      it 'should not print manage home debug messages' do
+        expect(Puppet).not_to receive(:debug).with(/Please make sure the path is not relative, symlink or '\/'./)
+        expect(Puppet).not_to receive(:debug).with(/it would remove the home directory '\/special\/other_user' of user 'other_user' also./)
+
+        provider.delete
+      end
+    end
+  end
+
+  describe '#deletecmd' do
+    it 'uses the -p flag when removing the user' do
+      allow(provider.class).to receive(:command).with(:delete).and_return('delete')
+      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
+
+      expect(provider.deletecmd).to eql(
+        ['delete', '-p', 'ia_module_args', provider.resource.name]
+      )
+    end
+  end
 end

data/spec/unit/provider/user/directoryservice_spec.rb

@@ -1142,7 +1142,7 @@ end
       provider.class.instance_variable_set(:@os_version, nil) if provider.class.instance_variable_defined? :@os_version
     end
 
-    it 'should call Facter.value(:macosx_productversion_major) ONLY ONCE no matter how ' +
+    it 'should call Puppet.runtime[:facter].value(:macosx_productversion_major) ONLY ONCE no matter how ' +
        'many times get_os_version() is called' do
       expect(Facter).to receive(:value).with(:macosx_productversion_major).once.and_return('10.8')
       expect(provider.class.get_os_version).to eq('10.8')