puppet 7.10.0-universal-darwin → 7.13.1-universal-darwin

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

@@ -106,7 +106,7 @@ describe "egrammar parsing containers" do
 
     context 'it should allow keywords as attribute names' do
       ['and', 'case', 'class', 'default', 'define', 'else', 'elsif', 'if', 'in', 'inherits', 'node', 'or',
-        'undef', 'unless', 'type', 'attr', 'function', 'private'].each do |keyword|
+        'undef', 'unless', 'type', 'attr', 'function', 'private', 'plan', 'apply'].each do |keyword|
         it "such as #{keyword}" do
           expect { parse("class x ($#{keyword}){} class { x: #{keyword} => 1 }") }.to_not raise_error
         end
@@ -178,7 +178,7 @@ describe "egrammar parsing containers" do
 
     context 'it should allow keywords as attribute names' do
       ['and', 'case', 'class', 'default', 'define', 'else', 'elsif', 'if', 'in', 'inherits', 'node', 'or',
-        'undef', 'unless', 'type', 'attr', 'function', 'private'].each do |keyword|
+        'undef', 'unless', 'type', 'attr', 'function', 'private', 'plan', 'apply'].each do |keyword|
         it "such as #{keyword}" do
           expect {parse("define x ($#{keyword}){} x { y: #{keyword} => 1 }")}.to_not raise_error
         end

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

@@ -559,29 +559,6 @@ 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
@@ -655,41 +632,6 @@ 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/pops/validator/validator_spec.rb

@@ -414,6 +414,11 @@ describe "validating 4x" do
         expect(acceptor.error_count).to eql(0)
       end
 
+      it 'allows apply to be used as a resource attribute name' do
+        acceptor = validate(parse('apply("foo.example.com") { sometype { "resourcetitle": apply => "applyvalue" } }'))
+        expect(acceptor.error_count).to eql(0)
+      end
+
       it 'accepts multiple arguments' do
         acceptor = validate(parse('apply(["foo.example.com"], { "other" => "args" }) { }'))
         expect(acceptor.error_count).to eql(0)

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

@@ -414,6 +414,21 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
               .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/gentoo_spec.rb

@@ -6,8 +6,8 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
 
   before :each do
     allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-    allow(FileTest).to receive(:file?).with('/sbin/rc-update').and_return(true)
-    allow(FileTest).to receive(:executable?).with('/sbin/rc-update').and_return(true)
+    allow(Puppet::FileSystem).to receive(:file?).with('/sbin/rc-update').and_return(true)
+    allow(Puppet::FileSystem).to receive(:executable?).with('/sbin/rc-update').and_return(true)
     allow(Facter).to receive(:value).with(:operatingsystem).and_return('Gentoo')
     allow(Facter).to receive(:value).with(:osfamily).and_return('Gentoo')
 
@@ -52,13 +52,14 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
     end
 
     it "should get a list of services from /etc/init.d but exclude helper scripts" do
-      expect(FileTest).to receive(:directory?).with('/etc/init.d').and_return(true)
+      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
+      allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
       expect(Dir).to receive(:entries).with('/etc/init.d').and_return(initscripts)
       (initscripts - helperscripts).each do |script|
-        expect(FileTest).to receive(:executable?).with("/etc/init.d/#{script}").and_return(true)
+        expect(Puppet::FileSystem).to receive(:executable?).with("/etc/init.d/#{script}").and_return(true)
       end
       helperscripts.each do |script|
-        expect(FileTest).not_to receive(:executable?).with("/etc/init.d/#{script}")
+        expect(Puppet::FileSystem).not_to receive(:executable?).with("/etc/init.d/#{script}")
       end
 
       allow(Puppet::FileSystem).to receive(:symlink?).and_return(false)

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

@@ -85,14 +85,20 @@ describe 'Puppet::Type::Service::Provider::Init',
       @services = ['one', 'two', 'three', 'four', 'umountfs']
       allow(Dir).to receive(:entries).and_call_original
       allow(Dir).to receive(:entries).with('tmp').and_return(@services)
-      expect(FileTest).to receive(:directory?).with('tmp').and_return(true)
-      allow(FileTest).to receive(:executable?).and_return(true)
+      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
+      allow(Puppet::FileSystem).to receive(:directory?).with('tmp').and_return(true)
+      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
     end
 
     it "should return instances for all services" do
       expect(provider_class.instances.map(&:name)).to eq(@services)
     end
 
+    it "should omit directories from the service list" do
+      expect(Puppet::FileSystem).to receive(:directory?).with('tmp/four').and_return(true)
+      expect(provider_class.instances.map(&:name)).to eq(@services - ['four'])
+    end
+
     it "should omit an array of services from exclude list" do
       exclude = ['two', 'four']
       expect(provider_class.get_services(provider_class.defpath, exclude).map(&:name)).to eq(@services - exclude)
@@ -140,9 +146,9 @@ describe 'Puppet::Type::Service::Provider::Init',
 
   describe "when checking valid paths" do
     it "should discard paths that do not exist" do
-      expect(File).to receive(:directory?).with(paths[0]).and_return(false)
+      expect(Puppet::FileSystem).to receive(:directory?).with(paths[0]).and_return(false)
       expect(Puppet::FileSystem).to receive(:exist?).with(paths[0]).and_return(false)
-      expect(File).to receive(:directory?).with(paths[1]).and_return(true)
+      expect(Puppet::FileSystem).to receive(:directory?).with(paths[1]).and_return(true)
 
       expect(provider.paths).to eq([paths[1]])
     end
@@ -150,7 +156,7 @@ describe 'Puppet::Type::Service::Provider::Init',
     it "should discard paths that are not directories" do
       paths.each do |path|
         expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect(File).to receive(:directory?).with(path).and_return(false)
+        expect(Puppet::FileSystem).to receive(:directory?).with(path).and_return(false)
       end
       expect(provider.paths).to be_empty
     end
@@ -158,7 +164,7 @@ describe 'Puppet::Type::Service::Provider::Init',
 
   describe "when searching for the init script" do
     before :each do
-      paths.each {|path| expect(File).to receive(:directory?).with(path).and_return(true) }
+      paths.each {|path| expect(Puppet::FileSystem).to receive(:directory?).with(path).and_return(true) }
     end
 
     it "should be able to find the init script in the service path" do
@@ -191,9 +197,9 @@ describe 'Puppet::Type::Service::Provider::Init',
 
   describe "if the init script is present" do
     before :each do
-      allow(File).to receive(:directory?).and_call_original
-      allow(File).to receive(:directory?).with("/service/path").and_return(true)
-      allow(File).to receive(:directory?).with("/alt/service/path").and_return(true)
+      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
+      allow(Puppet::FileSystem).to receive(:directory?).with("/service/path").and_return(true)
+      allow(Puppet::FileSystem).to receive(:directory?).with("/alt/service/path").and_return(true)
       allow(Puppet::FileSystem).to receive(:exist?).with("/service/path/myservice").and_return(true)
     end
 

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

@@ -2,63 +2,56 @@ require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Openwrt',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
+
   let(:provider_class) { Puppet::Type.type(:service).provider(:openwrt) }
 
   let(:resource) do
-    resource = double('resource')
-    allow(resource).to receive(:[]).and_return(nil)
-    allow(resource).to receive(:[]).with(:name).and_return("myservice")
-    allow(resource).to receive(:[]).with(:path).and_return(["/etc/init.d"])
-
-    resource
+    Puppet::Type.type(:service).new(
+      :name       => 'myservice',
+      :path       => '/etc/init.d',
+      :hasrestart => true,
+    )
   end
 
   let(:provider) do
     provider = provider_class.new
-    allow(provider).to receive(:get).with(:hasstatus).and_return(false)
-
+    provider.resource = resource
     provider
   end
 
   before :each do
-    allow(resource).to receive(:provider).and_return(provider)
-    provider.resource = resource
-
-    allow(FileTest).to receive(:file?).with('/etc/rc.common').and_return(true)
-    allow(FileTest).to receive(:executable?).with('/etc/rc.common').and_return(true)
+    resource.provider = provider
 
     # All OpenWrt tests operate on the init script directly. It must exist.
-    allow(File).to receive(:directory?).and_call_original
-    allow(File).to receive(:directory?).with('/etc/init.d').and_return(true)
+    allow(Puppet::FileSystem).to receive(:directory?).and_call_original
+    allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
 
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/init.d/myservice').and_return(true)
-    allow(FileTest).to receive(:file?).and_call_original
-    allow(FileTest).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
-    allow(FileTest).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
+    allow(Puppet::FileSystem).to receive(:file?).and_call_original
+    allow(Puppet::FileSystem).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
+    allow(Puppet::FileSystem).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
   end
 
-  operatingsystem = 'openwrt'
-  it "should be the default provider on #{operatingsystem}" do
-    expect(Facter).to receive(:value).with(:operatingsystem).and_return(operatingsystem)
+  it "should be the default provider on 'openwrt'" do
+    expect(Facter).to receive(:value).with(:operatingsystem).and_return('openwrt')
     expect(provider_class.default?).to be_truthy
   end
 
   # test self.instances
   describe "when getting all service instances" do
-    let(:services) {['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ]}
+    let(:services) { ['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ] }
 
     before :each do
       allow(Dir).to receive(:entries).and_call_original
       allow(Dir).to receive(:entries).with('/etc/init.d').and_return(services)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:executable?).and_return(true)
+      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
     end
 
     it "should return instances for all services" do
       services.each do |inst|
         expect(provider_class).to receive(:new).with(hash_including(:name => inst, :path => '/etc/init.d')).and_return("#{inst}_instance")
       end
-      results = services.collect {|x| "#{x}_instance"}
+      results = services.collect { |x| "#{x}_instance"}
       expect(provider_class.instances).to eq(results)
     end
   end
@@ -82,14 +75,13 @@ describe 'Puppet::Type::Service::Provider::Openwrt',
 
     describe "when running #{method}" do
       it "should use any provided explicit command" do
-        allow(resource).to receive(:[]).with(method).and_return("/user/specified/command")
-        expect(provider).to receive(:execute).with(["/user/specified/command"], any_args)
+        resource[method] = '/user/specified/command'
+        expect(provider).to receive(:execute).with(['/user/specified/command'], any_args)
         provider.send(method)
       end
 
       it "should execute the init script with #{method} when no explicit command is provided" do
-        allow(resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
-        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method ], any_args)
+        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method], any_args)
         provider.send(method)
       end
     end

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

@@ -41,8 +41,9 @@ describe 'Puppet::Type::Service::Provider::Redhat',
       @services = ['one', 'two', 'three', 'four', 'kudzu', 'functions', 'halt', 'killall', 'single', 'linuxconf', 'boot', 'reboot']
       @not_services = ['functions', 'halt', 'killall', 'single', 'linuxconf', 'reboot', 'boot']
       allow(Dir).to receive(:entries).and_return(@services)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:executable?).and_return(true)
+      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
+      allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
+      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
     end
 
     it "should return instances for all services" do

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')

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

@@ -352,6 +352,46 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
   end
 
+  describe "#shell" do
+    before { described_class.has_feature :manages_local_users_and_groups }
+
+    let(:content) { "myuser:x:x:x:x:x:/bin/local_shell" }
+
+    it "should return the local shell string when forcelocal is true" do
+      resource[:forcelocal] = true
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/passwd').and_return(true)
+      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/passwd').and_yield(content)
+      expect(provider.shell).to eq('/bin/local_shell')
+    end
+
+    it "should fall back to nameservice shell string when forcelocal is false" do
+      resource[:forcelocal] = false
+      allow(provider).to receive(:get).with(:shell).and_return('/bin/remote_shell')
+      expect(provider).not_to receive(:localshell)
+      expect(provider.shell).to eq('/bin/remote_shell')
+    end
+  end
+
+  describe "#home" do
+    before { described_class.has_feature :manages_local_users_and_groups }
+
+    let(:content) { "myuser:x:x:x:x:/opt/local_home:x" }
+
+    it "should return the local home string when forcelocal is true" do
+      resource[:forcelocal] = true
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/passwd').and_return(true)
+      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/passwd').and_yield(content)
+      expect(provider.home).to eq('/opt/local_home')
+    end
+
+    it "should fall back to nameservice home string when forcelocal is false" do
+      resource[:forcelocal] = false
+      allow(provider).to receive(:get).with(:home).and_return('/opt/remote_home')
+      expect(provider).not_to receive(:localhome)
+      expect(provider.home).to eq('/opt/remote_home')
+    end
+  end
+
   describe "#gid" do
     before { described_class.has_feature :manages_local_users_and_groups }
 

data/spec/unit/provider_spec.rb

@@ -222,18 +222,18 @@ describe Puppet::Provider do
       { :true => false } => false,
       { :false => false } => true,
       { :false => true } => false,
-      { :operatingsystem => Facter.value(:operatingsystem) } => true,
+      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem) } => true,
       { :operatingsystem => :yayness } => false,
       { :nothing => :yayness } => false,
       { :exists => Puppet::Util.which(existing_command) } => true,
       { :exists => "/this/file/does/not/exist" } => false,
       { :true => true, :exists => Puppet::Util.which(existing_command) } => true,
       { :true => true, :exists => "/this/file/does/not/exist" } => false,
-      { :operatingsystem => Facter.value(:operatingsystem),
+      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
         :exists => Puppet::Util.which(existing_command) } => true,
       { :operatingsystem => :yayness,
         :exists => Puppet::Util.which(existing_command) } => false,
-      { :operatingsystem => Facter.value(:operatingsystem),
+      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
         :exists => "/this/file/does/not/exist" } => false,
       { :operatingsystem => :yayness,
         :exists => "/this/file/does/not/exist" } => false,
@@ -269,7 +269,7 @@ describe Puppet::Provider do
   end
 
   context "default providers" do
-    let :os do Facter.value(:operatingsystem) end
+    let :os do Puppet.runtime[:facter].value(:operatingsystem) end
 
     it { is_expected.to respond_to :specificity }