puppet 6.4.5-x64-mingw32 → 6.5.0-x64-mingw32

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

@@ -163,28 +163,4 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
       expect(@provider.status).to  eq(:stopped)
     end
   end
-
-  context '.instances' do
-    before do
-      allow(provider_class).to receive(:defpath).and_return(path)
-    end
-
-    context 'when defpath is nil' do
-      let(:path) { nil }
-
-      it 'returns info message' do
-        expect(Puppet).to receive(:info).with(/daemontools is unsuitable because service directory is nil/)
-        provider_class.instances
-      end
-    end
-
-    context 'when defpath does not exist' do
-      let(:path) { '/inexistent_path' }
-
-      it 'returns notice about missing path' do
-        expect(Puppet).to receive(:notice).with(/Service path #{path} does not exist/)
-        provider_class.instances
-      end
-    end
-  end
 end

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

@@ -127,8 +127,6 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   end
 
   describe "when starting the service" do
-    let(:services) { "12345 0 #{joblabel}"  }
-
     it "should call any explicit 'start' command" do
       resource[:start] = "/bin/false"
       expect(subject).to receive(:texecute).with(:start, ["/bin/false"], true)
@@ -136,7 +134,6 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
     end
 
     it "should look for the relevant plist once" do
-      allow(provider).to receive(:launchctl).with(:list).and_return(services)
       expect(subject).to receive(:plist_from_label).and_return([joblabel, {}]).once
       expect(subject).to receive(:enabled?).and_return(:true)
       expect(subject).to receive(:execute).with([:launchctl, :load, "-w", joblabel])
@@ -144,7 +141,6 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
     end
 
     it "should execute 'launchctl load' once without writing to the plist if the job is enabled" do
-      allow(provider).to receive(:launchctl).with(:list).and_return(services)
       expect(subject).to receive(:plist_from_label).and_return([joblabel, {}])
       expect(subject).to receive(:enabled?).and_return(:true)
       expect(subject).to receive(:execute).with([:launchctl, :load, "-w", joblabel]).once
@@ -248,30 +244,6 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
     end
   end
 
-  describe "when a service is unavailable" do
-    let(:map) { {"some.random.job" => "/path/to/job.plist"} }
-    
-    before :each do
-      allow(provider).to receive(:make_label_to_path_map).and_return(map)
-    end
-
-    it "should fail when searching for the unavailable service" do
-      expect { provider.jobsearch("NOSUCH") }.to raise_error(Puppet::Error)
-    end
-
-    it "should return false when enabling the service" do
-      expect(subject.enabled?).to eq(:false)
-    end
-
-    it "should fail when starting the service" do
-      expect { subject.start }.to raise_error(Puppet::Error)
-    end
-
-    it "should fail when starting the service" do
-      expect { subject.stop }.to raise_error(Puppet::Error)
-    end
-  end
-
   [[10, "10.6"], [13, "10.9"]].each do |kernel, version|
     describe "when enabling the service on OS X #{version}" do
       it "should write to the global launchd overrides file once" do

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

@@ -136,28 +136,4 @@ describe 'Puppet::Type::Service::Provider::Runit', unless: Puppet::Util::Platfor
       expect(@provider.status).to eq(:stopped)
     end
   end
-
-  context '.instances' do
-    before do
-      allow(provider_class).to receive(:defpath).and_return(path)
-    end
-
-    context 'when defpath is nil' do
-      let(:path) { nil }
-
-      it 'returns info message' do
-        expect(Puppet).to receive(:info).with(/runit is unsuitable because service directory is nil/)
-        provider_class.instances
-      end
-    end
-
-    context 'when defpath does not exist' do
-      let(:path) { '/inexistent_path' }
-
-      it 'returns notice about missing path' do
-        expect(Puppet).to receive(:notice).with(/Service path #{path} does not exist/)
-        provider_class.instances
-      end
-    end
-  end
 end

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

@@ -120,20 +120,6 @@ describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platf
     expect(provider_class).to be_default
   end
 
-  it "should be the default provider on debian11" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("11")
-    expect(provider_class).to be_default
-  end
-
-  it "should be the default provider on debian bookworm/sid" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("bookworm/sid")
-    expect(provider_class).to be_default
-  end
-
   it "should not be the default provider on ubuntu14.04" do
     allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
     allow(Facter).to receive(:value).with(:operatingsystem).and_return(:ubuntu)
@@ -201,17 +187,17 @@ describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platf
 
     it "should start the service with systemctl start otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:systemctl).with(:unmask, '--', 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:unmask, 'sshd.service')
       expect(provider).to receive(:daemon_reload?).and_return('no')
-      expect(provider).to receive(:execute).with(['/bin/systemctl','start', '--', 'sshd.service'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      expect(provider).to receive(:execute).with(['/bin/systemctl','start','sshd.service'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.start
     end
 
     it "should show journald logs on failure" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:systemctl).with(:unmask, '--', 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:unmask, 'sshd.service')
       expect(provider).to receive(:daemon_reload?).and_return('no')
-      expect(provider).to receive(:execute).with(['/bin/systemctl','start', '--', 'sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      expect(provider).to receive(:execute).with(['/bin/systemctl','start','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
         .and_raise(Puppet::ExecutionFailure, "Failed to start sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
       journalctl_logs = <<-EOS
 -- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --
@@ -233,13 +219,13 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
 
     it "should stop the service with systemctl stop otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','stop', '--', 'sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','stop','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
 
     it "should show journald logs on failure" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','stop', '--', 'sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      expect(provider).to receive(:execute).with(['/bin/systemctl','stop','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
         .and_raise(Puppet::ExecutionFailure, "Failed to stop sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
       journalctl_logs = <<-EOS
 -- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --
@@ -255,13 +241,13 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#daemon_reload?" do
     it "should skip the systemctl daemon_reload if not required by the service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl', 'show', '--property=NeedDaemonReload', '--', 'sshd.service'], :failonfail => false).and_return("no")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','show','sshd.service','--property=NeedDaemonReload'], :failonfail => false).and_return("no")
       provider.daemon_reload?
     end
     it "should run a systemctl daemon_reload if the service has been modified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl', 'show', '--property=NeedDaemonReload', '--', 'sshd.service'], :failonfail => false).and_return("yes")
-      expect(provider).to receive(:execute).with(['/bin/systemctl', 'daemon-reload'], :failonfail => false)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','show','sshd.service','--property=NeedDaemonReload'], :failonfail => false).and_return("yes")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','daemon-reload'], :failonfail => false)
       provider.daemon_reload?
     end
   end
@@ -269,42 +255,42 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#enabled?" do
     it "should return :true if the service is enabled" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).and_return("enabled\n")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("enabled\n")
       allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :true if the service is static" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','--', 'sshd.service'], :failonfail => false).and_return("static\n")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("static\n")
       allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :false if the service is disabled" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).and_return("disabled\n")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("disabled\n")
       allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :false if the service is indirect" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).and_return("indirect\n")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("indirect\n")
       allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :false if the service is masked and the resource is attempting to be disabled" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => false))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).and_return("masked\n")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("masked\n")
       allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :mask if the service is masked and the resource is attempting to be masked" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => 'mask'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).and_return("masked\n")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("masked\n")
       allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
       expect(provider.enabled?).to eq(:mask)
     end
@@ -313,8 +299,8 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#enable" do
     it "should run systemctl enable to enable a service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:systemctl).with(:unmask, '--', 'sshd.service')
-      expect(provider).to receive(:systemctl).with(:enable, '--', 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:unmask, 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:enable, 'sshd.service')
       provider.enable
     end
   end
@@ -322,7 +308,7 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#disable" do
     it "should run systemctl disable to disable a service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:systemctl).with(:disable, '--', 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:disable, 'sshd.service')
       provider.disable
     end
   end
@@ -333,8 +319,8 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
       # :disable is the only call in the provider that uses a symbol instead of
       # a string.
       # This should be made consistent in the future and all tests updated.
-      expect(provider).to receive(:systemctl).with(:disable, '--', 'sshd.service')
-      expect(provider).to receive(:systemctl).with(:mask, '--', 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:disable, 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:mask, 'sshd.service')
       provider.mask
     end
   end
@@ -344,7 +330,7 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#status" do
     it "should return running if if the command returns 0" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-active', '--', 'sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).and_return("active\n")
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).and_return("active\n")
       allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
       expect(provider.status).to eq(:running)
     end
@@ -352,7 +338,7 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     [-10,-1,3,10].each { |ec|
       it "should return stopped if the command returns something non-0" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        expect(provider).to receive(:execute).with(['/bin/systemctl','is-active', '--', 'sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).and_return("inactive\n")
+        expect(provider).to receive(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).and_return("inactive\n")
         allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
         expect(provider.status).to eq(:stopped)
       end
@@ -371,7 +357,7 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     it "should use the supplied restart command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
       expect(provider).to receive(:daemon_reload?).and_return('no')
-      expect(provider).to receive(:execute).with(['/bin/systemctl','restart', '--', 'sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      expect(provider).to receive(:execute).with(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
       expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
@@ -379,14 +365,14 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     it "should restart the service with systemctl restart" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
       expect(provider).to receive(:daemon_reload?).and_return('no')
-      expect(provider).to receive(:execute).with(['/bin/systemctl','restart','--','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should show journald logs on failure" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
       expect(provider).to receive(:daemon_reload?).and_return('no')
-      expect(provider).to receive(:execute).with(['/bin/systemctl','restart','--','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      expect(provider).to receive(:execute).with(['/bin/systemctl','restart','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
         .and_raise(Puppet::ExecutionFailure, "Failed to restart sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
       journalctl_logs = <<-EOS
 -- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --

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

@@ -150,11 +150,6 @@ describe 'Puppet::Type::Service::Provider::Windows',
       expect(provider.enabled?).to eq(:manual)
     end
 
-    it "should report a service with a startup type of delayed as delayed" do
-      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DELAYED_AUTO_START)
-      expect(provider.enabled?).to eq(:delayed)
-    end
-
     it "should report a service with a startup type of disabled as false" do
       expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DISABLED)
       expect(provider.enabled?).to eq(:false)
@@ -220,19 +215,4 @@ describe 'Puppet::Type::Service::Provider::Windows',
       }.to raise_error(Puppet::Error, /Cannot enable #{name}/)
     end
   end
-
-  describe "#delayed_start" do
-    it "should set service start type to Service_Config_Delayed_Auto_Start (delayed) when delayed" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START, true)
-      provider.delayed_start
-    end
-
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START, true).and_raise(Puppet::Error.new('foobar'))
-
-      expect {
-        provider.delayed_start
-      }.to raise_error(Puppet::Error, /Cannot enable #{name}/)
-    end
-  end
 end

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

@@ -58,14 +58,14 @@ describe Puppet::Type.type(:user).provider(:hpuxuseradd),
     it "should add modprpw to modifycmd if Trusted System" do
       allow(resource).to receive(:allowdupe?).and_return(true)
       expect(provider).to receive(:exec_getprpw).with('root','-m uid').and_return('uid=0')
-      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-F', '-u', 1000, '-o', 'testuser', ';', '/usr/lbin/modprpw', '-v', '-l', 'testuser'], hash_including(custom_environment: {}))
+      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F', ';', '/usr/lbin/modprpw', '-v', '-l', 'testuser'], hash_including(custom_environment: {}))
       provider.uid = 1000
     end
 
     it "should not add modprpw if not Trusted System" do
       allow(resource).to receive(:allowdupe?).and_return(true)
       expect(provider).to receive(:exec_getprpw).with('root','-m uid').and_return('System is not trusted')
-      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-F', '-u', 1000, '-o', 'testuser'], hash_including(custom_environment: {}))
+      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F'], hash_including(custom_environment: {}))
       provider.uid = 1000
     end
   end

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'open3'
 
 RSpec::Matchers.define_negated_matcher :excluding, :include
 
@@ -82,23 +81,6 @@ describe Puppet::Type.type(:user).provider(:pw) do
       provider.create
     end
 
-    it "should call execute with sensitive true when the password property is set" do
-      Puppet::Util::Log.level = :debug
-      resource[:password] = "abc123"
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true))
-      popen = double("popen", :puts => nil, :close => nil)
-      expect(Open3).to receive(:popen3).and_return(popen)
-      expect(popen).to receive(:puts).with("abc123")
-      provider.create
-      expect(@logs).not_to be_any {|log| log.level == :debug and log.message =~ /abc123/}
-    end
-
-    it "should call execute with sensitive false when a non-sensitive property is set" do
-      resource[:managehome] = true
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: false))
-      provider.create
-    end
-
     it "should use -s with the correct argument when the shell property is set" do
       resource[:shell] = "/bin/sh"
       expect(provider).to receive(:execute).with(include("-s").and(include("/bin/sh")), kind_of(Hash))
@@ -227,24 +209,5 @@ describe Puppet::Type.type(:user).provider(:pw) do
       expect(provider).to receive(:execute).with(include("-u").and(include(54321)), hash_including(custom_environment: {}))
       provider.uid = 54321
     end
-
-    it "should print a debug message with sensitive data redacted when the password property is set" do
-      Puppet::Util::Log.level = :debug
-      resource[:password] = "*"
-      popen = double("popen", :puts => nil, :close => nil)
-      expect(Open3).to receive(:popen3).and_return(popen)
-      expect(popen).to receive(:puts).with("abc123")
-      provider.password = "abc123"
-
-      expect(@logs).not_to be_any {|log| log.level == :debug and log.message =~ /abc123/}
-     end
-
-    it "should call execute with sensitive false when a non-sensitive property is set" do
-      Puppet::Util::Log.level = :debug
-      resource[:home] = "/home/testuser"
-      resource[:managehome] = true
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: false))
-      provider.home = "/newhome/testuser"
-    end
   end
 end

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

@@ -44,27 +44,6 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       allow(provider).to receive(:exists?).and_return(false)
     end
 
-    it "should not redact the command from debug logs if there is no password" do
-      described_class.has_feature :manages_passwords
-      resource[:ensure] = :present
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: false))
-      provider.create
-    end
-
-    it "should redact the command from debug logs if there is a password" do
-      described_class.has_feature :manages_passwords
-      resource2 = Puppet::Type.type(:user).new(
-        :name       => 'myuser',
-        :password   => 'a pass word',
-        :managehome => :false,
-        :system     => :false,
-        :provider   => provider,
-      )
-      resource2[:ensure] = :present
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true))
-      provider.create
-    end
-
     it "should add -g when no gid is specified and group already exists" do
       allow(Puppet::Util).to receive(:gid).and_return(true)
       resource[:ensure] = :present
@@ -186,27 +165,6 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
   end
 
-  describe 'when modifying the password' do
-    before do
-      described_class.has_feature :libuser
-      described_class.has_feature :manages_passwords
-      #Setting any resource value here initializes needed variables and methods in the resource and provider
-      #Setting a password value here initializes the existence and management of the password parameter itself
-      #Otherwise, this value would not need to be initialized for the test
-      resource[:password] = ''
-    end
-
-    it "should not call execute with sensitive if non-sensitive data is changed" do
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: false))
-      provider.home = 'foo/bar'
-    end
-
-    it "should call execute with sensitive if sensitive data is changed" do
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true))
-      provider.password = 'bird bird bird'
-    end
-  end
-
   describe '#modify' do
     describe "on systems with the libuser and forcelocal=false" do
       before do
@@ -317,52 +275,6 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
   end
 
-  describe "#comment" do
-    before { described_class.has_feature :libuser }
-
-    let(:content) { "myuser:x:x:x:local comment:x:x" }
-
-    it "should return the local comment string when forcelocal is true" do
-      resource[:forcelocal] = true
-      allow(File).to receive(:open).with('/etc/passwd').and_yield(content)
-      expect(provider.comment).to eq('local comment')
-    end
-
-    it "should fall back to nameservice comment string when forcelocal is false" do
-      resource[:forcelocal] = false
-      allow(provider).to receive(:get).with(:comment).and_return('remote comment')
-      expect(provider).not_to receive(:localcomment)
-      expect(provider.comment).to eq('remote comment')
-    end
-  end
-
-  describe "#finduser" do
-    before { allow(File).to receive(:open).with('/etc/passwd').and_yield(content) }
-
-    let(:content) { "sample_account:sample_password:sample_uid:sample_gid:sample_gecos:sample_directory:sample_shell" }
-    let(:output) do
-      {
-        account: 'sample_account',
-        password: 'sample_password',
-        uid: 'sample_uid',
-        gid: 'sample_gid',
-        gecos: 'sample_gecos',
-        directory: 'sample_directory',
-        shell: 'sample_shell',
-      }
-    end
-
-    [:account, :password, :uid, :gid, :gecos, :directory, :shell].each do |key|
-      it "finds an user by #{key} when asked" do
-        expect(provider.finduser(key, "sample_#{key}")).to eq(output)
-      end
-    end
-
-    it "returns false when specified key/value pair is not found" do
-      expect(provider.finduser(:account, 'invalid_account')).to eq(false)
-    end
-  end
-
   describe "#check_allow_dup" do
     it "should return an array with a flag if dup is allowed" do
       resource[:allowdupe] = :true