puppet 7.27.0-x86-mingw32 → 7.29.0-x86-mingw32

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

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'etc'
-
-describe Puppet::Type.type(:user).provider(:hpuxuseradd),
-         unless: Puppet::Util::Platform.windows? do
-  let :resource do
-    Puppet::Type.type(:user).new(
-      :title => 'testuser',
-      :comment => 'Test J. User',
-      :provider => :hpuxuseradd
-    )
-  end
-  let(:provider) { resource.provider }
-
-  it "should add -F when modifying a user" do
-    allow(resource).to receive(:allowdupe?).and_return(true)
-    allow(provider).to receive(:trusted).and_return(true)
-    expect(provider).to receive(:execute).with(include("-F"), anything)
-    provider.uid = 1000
-  end
-
-  it "should add -F when deleting a user" do
-    allow(provider).to receive(:exists?).and_return(true)
-    expect(provider).to receive(:execute).with(include("-F"), anything)
-    provider.delete
-  end
-
-  context "managing passwords" do
-    let :pwent do
-      Etc::Passwd.new("testuser", "foopassword")
-    end
-
-    before :each do
-      allow(Etc).to receive(:getpwent).and_return(pwent)
-      allow(Etc).to receive(:getpwnam).and_return(pwent)
-      allow(provider).to receive(:command).with(:modify).and_return('/usr/sam/lbin/usermod.sam')
-    end
-
-    it "should have feature manages_passwords" do
-      expect(described_class).to be_manages_passwords
-    end
-
-    it "should return nil if user does not exist" do
-      allow(Etc).to receive(:getpwent).and_return(nil)
-      expect(provider.password).to be_nil
-    end
-
-    it "should return password entry if exists" do
-      expect(provider.password).to eq("foopassword")
-    end
-  end
-
-  context "check for trusted computing" do
-    before :each do
-      allow(provider).to receive(:command).with(:modify).and_return('/usr/sam/lbin/usermod.sam')
-    end
-
-    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: {}))
-      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: {}))
-      provider.uid = 1000
-    end
-  end
-end

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

@@ -1,286 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:user).provider(:ldap) do
-  it "should have the Ldap provider class as its baseclass" do
-    expect(described_class.superclass).to equal(Puppet::Provider::Ldap)
-  end
-
-  it "should manage :posixAccount and :person objectclasses" do
-    expect(described_class.manager.objectclasses).to eq([:posixAccount, :person])
-  end
-
-  it "should use 'ou=People' as its relative base" do
-    expect(described_class.manager.location).to eq("ou=People")
-  end
-
-  it "should use :uid as its rdn" do
-    expect(described_class.manager.rdn).to eq(:uid)
-  end
-
-  it "should be able to manage passwords" do
-    expect(described_class).to be_manages_passwords
-  end
-
-  {:name => "uid",
-    :password => "userPassword",
-    :comment => "cn",
-    :uid => "uidNumber",
-    :gid => "gidNumber",
-    :home => "homeDirectory",
-    :shell => "loginShell"
-  }.each do |puppet, ldap|
-    it "should map :#{puppet.to_s} to '#{ldap}'" do
-      expect(described_class.manager.ldap_name(puppet)).to eq(ldap)
-    end
-  end
-
-  context "when being created" do
-    before do
-      # So we don't try to actually talk to ldap
-      @connection = double('connection')
-      allow(described_class.manager).to receive(:connect).and_yield(@connection)
-    end
-
-    it "should generate the sn as the last field of the cn" do
-      expect(Puppet::Type.type(:group).provider(:ldap)).to receive(:name2id).with(["whatever"]).and_return([123])
-
-      resource = double('resource', :should => %w{whatever})
-      allow(resource).to receive(:should).with(:comment).and_return(["Luke Kanies"])
-      allow(resource).to receive(:should).with(:ensure).and_return(:present)
-      instance = described_class.new(:name => "luke", :ensure => :absent)
-
-      allow(instance).to receive(:resource).and_return(resource)
-
-      expect(@connection).to receive(:add).with(anything, hash_including("sn" => ["Kanies"]))
-
-      instance.create
-      instance.flush
-    end
-
-    it "should translate a group name to the numeric id" do
-      expect(Puppet::Type.type(:group).provider(:ldap)).to receive(:name2id).with("bar").and_return(101)
-
-      resource = double('resource', :should => %w{whatever})
-      allow(resource).to receive(:should).with(:gid).and_return('bar')
-      allow(resource).to receive(:should).with(:ensure).and_return(:present)
-      instance = described_class.new(:name => "luke", :ensure => :absent)
-      allow(instance).to receive(:resource).and_return(resource)
-
-      expect(@connection).to receive(:add).with(anything, hash_including("gidNumber" => ["101"]))
-
-      instance.create
-      instance.flush
-    end
-
-    context "with no uid specified" do
-      it "should pick the first available UID after the largest existing UID" do
-        expect(Puppet::Type.type(:group).provider(:ldap)).to receive(:name2id).with(["whatever"]).and_return([123])
-
-        low = {:name=>["luke"], :shell=>:absent, :uid=>["600"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["l k"]}
-        high = {:name=>["testing"], :shell=>:absent, :uid=>["640"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["t u"]}
-        expect(described_class.manager).to receive(:search).and_return([low, high])
-
-        resource = double('resource', :should => %w{whatever})
-        allow(resource).to receive(:should).with(:uid).and_return(nil)
-        allow(resource).to receive(:should).with(:ensure).and_return(:present)
-        instance = described_class.new(:name => "luke", :ensure => :absent)
-        allow(instance).to receive(:resource).and_return(resource)
-
-        expect(@connection).to receive(:add).with(anything, hash_including("uidNumber" => ["641"]))
-
-        instance.create
-        instance.flush
-      end
-
-      it "should pick 501 of no users exist" do
-        expect(Puppet::Type.type(:group).provider(:ldap)).to receive(:name2id).with(["whatever"]).and_return([123])
-
-        expect(described_class.manager).to receive(:search).and_return(nil)
-
-        resource = double('resource', :should => %w{whatever})
-        allow(resource).to receive(:should).with(:uid).and_return(nil)
-        allow(resource).to receive(:should).with(:ensure).and_return(:present)
-        instance = described_class.new(:name => "luke", :ensure => :absent)
-        allow(instance).to receive(:resource).and_return(resource)
-
-        expect(@connection).to receive(:add).with(anything, hash_including("uidNumber" => ["501"]))
-
-        instance.create
-        instance.flush
-      end
-    end
-  end
-
-  context "when flushing" do
-    before do
-      allow(described_class).to receive(:suitable?).and_return(true)
-
-      @instance = described_class.new(:name => "myname", :groups => %w{whatever}, :uid => "400")
-    end
-
-    it "should remove the :groups value before updating" do
-      expect(@instance.class.manager).to receive(:update).with(anything, anything, hash_excluding(:groups))
-
-      @instance.flush
-    end
-
-    it "should empty the property hash" do
-      allow(@instance.class.manager).to receive(:update)
-
-      @instance.flush
-
-      expect(@instance.uid).to eq(:absent)
-    end
-
-    it "should empty the ldap property hash" do
-      allow(@instance.class.manager).to receive(:update)
-
-      @instance.flush
-
-      expect(@instance.ldap_properties[:uid]).to be_nil
-    end
-  end
-
-  context "when checking group membership" do
-    before do
-      @groups = Puppet::Type.type(:group).provider(:ldap)
-      @group_manager = @groups.manager
-      allow(described_class).to receive(:suitable?).and_return(true)
-
-      @instance = described_class.new(:name => "myname")
-    end
-
-    it "should show its group membership as the sorted list of all groups returned by an ldap query of group memberships" do
-      one = {:name => "one"}
-      two = {:name => "two"}
-      expect(@group_manager).to receive(:search).with("memberUid=myname").and_return([two, one])
-
-      expect(@instance.groups).to eq("one,two")
-    end
-
-    it "should show its group membership as :absent if no matching groups are found in ldap" do
-      expect(@group_manager).to receive(:search).with("memberUid=myname").and_return(nil)
-
-      expect(@instance.groups).to eq(:absent)
-    end
-
-    it "should cache the group value" do
-      expect(@group_manager).to receive(:search).with("memberUid=myname").once.and_return(nil)
-
-      @instance.groups
-      expect(@instance.groups).to eq(:absent)
-    end
-  end
-
-  context "when modifying group membership" do
-    before do
-      @groups = Puppet::Type.type(:group).provider(:ldap)
-      @group_manager = @groups.manager
-      allow(described_class).to receive(:suitable?).and_return(true)
-
-      @one = {:name => "one", :gid => "500"}
-      allow(@group_manager).to receive(:find).with("one").and_return(@one)
-
-      @two = {:name => "one", :gid => "600"}
-      allow(@group_manager).to receive(:find).with("two").and_return(@two)
-
-      @instance = described_class.new(:name => "myname")
-
-      allow(@instance).to receive(:groups).and_return(:absent)
-    end
-
-    it "should fail if the group does not exist" do
-      expect(@group_manager).to receive(:find).with("mygroup").and_return(nil)
-
-      expect { @instance.groups = "mygroup" }.to raise_error(Puppet::Error)
-    end
-
-    it "should only pass the attributes it cares about to the group manager" do
-      expect(@group_manager).to receive(:update).with(anything, hash_excluding(:gid), anything)
-
-      @instance.groups = "one"
-    end
-
-    it "should always include :ensure => :present in the current values" do
-      expect(@group_manager).to receive(:update).with(anything, hash_including(ensure: :present), anything)
-
-      @instance.groups = "one"
-    end
-
-    it "should always include :ensure => :present in the desired values" do
-      expect(@group_manager).to receive(:update).with(anything, anything, hash_including(ensure: :present))
-
-      @instance.groups = "one"
-    end
-
-    it "should always pass the group's original member list" do
-      @one[:members] = %w{yay ness}
-      expect(@group_manager).to receive(:update).with(anything, hash_including(members: %w{yay ness}), anything)
-
-      @instance.groups = "one"
-    end
-
-    it "should find the group again when resetting its member list, so it has the full member list" do
-      expect(@group_manager).to receive(:find).with("one").and_return(@one)
-
-      allow(@group_manager).to receive(:update)
-
-      @instance.groups = "one"
-    end
-
-    context "for groups that have no members" do
-      it "should create a new members attribute with its value being the user's name" do
-        expect(@group_manager).to receive(:update).with(anything, anything, hash_including(members: %w{myname}))
-
-        @instance.groups = "one"
-      end
-    end
-
-    context "for groups it is being removed from" do
-      it "should replace the group's member list with one missing the user's name" do
-        @one[:members] = %w{myname a}
-        @two[:members] = %w{myname b}
-
-        expect(@group_manager).to receive(:update).with("two", anything, hash_including(members: %w{b}))
-
-        allow(@instance).to receive(:groups).and_return("one,two")
-        @instance.groups = "one"
-      end
-
-      it "should mark the member list as empty if there are no remaining members" do
-        @one[:members] = %w{myname}
-        @two[:members] = %w{myname b}
-
-        expect(@group_manager).to receive(:update).with("one", anything, hash_including(members: :absent))
-
-        allow(@instance).to receive(:groups).and_return("one,two")
-        @instance.groups = "two"
-      end
-    end
-
-    context "for groups that already have members" do
-      it "should replace each group's member list with a new list including the user's name" do
-        @one[:members] = %w{a b}
-        expect(@group_manager).to receive(:update).with(anything, anything, hash_including(members: %w{a b myname}))
-        @two[:members] = %w{b c}
-        expect(@group_manager).to receive(:update).with(anything, anything, hash_including(members: %w{b c myname}))
-
-        @instance.groups = "one,two"
-      end
-    end
-
-    context "for groups of which it is a member" do
-      it "should do nothing" do
-        @one[:members] = %w{a b}
-        expect(@group_manager).to receive(:update).with(anything, anything, hash_including(members: %w{a b myname}))
-
-        @two[:members] = %w{c myname}
-        expect(@group_manager).not_to receive(:update).with("two", any_args)
-
-        allow(@instance).to receive(:groups).and_return("two")
-
-        @instance.groups = "one,two"
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:user).provider(:openbsd) do
-  before :each do
-    allow(described_class).to receive(:command).with(:password).and_return('/usr/sbin/passwd')
-    allow(described_class).to receive(:command).with(:add).and_return('/usr/sbin/useradd')
-    allow(described_class).to receive(:command).with(:modify).and_return('/usr/sbin/usermod')
-    allow(described_class).to receive(:command).with(:delete).and_return('/usr/sbin/userdel')
-  end
-
-  let(:resource) do
-    Puppet::Type.type(:user).new(
-      :name       => 'myuser',
-      :managehome => :false,
-      :system     => :false,
-      :loginclass => 'staff',
-      :provider   => provider
-    )
-  end
-
-  let(:provider) { described_class.new(:name => 'myuser') }
-
-  let(:shadow_entry) {
-    return unless Puppet.features.libshadow?
-    entry = Etc::PasswdEntry.new
-    entry[:sp_namp]   = 'myuser' # login name
-    entry[:sp_loginclass] = 'staff' # login class
-    entry
-  }
-
-  describe "#expiry=" do
-    it "should pass expiry to usermod as MM/DD/YY" do
-      resource[:expiry] = '2014-11-05'
-      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', 'November 05 2014', 'myuser'], hash_including(custom_environment: {}))
-      provider.expiry = '2014-11-05'
-    end
-
-    it "should use -e with an empty string when the expiry property is removed" do
-      resource[:expiry] = :absent
-      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', '', 'myuser'], hash_including(custom_environment: {}))
-      provider.expiry = :absent
-    end
-  end
-
-  describe "#addcmd" do
-    it "should return an array with the full command and expiry as MM/DD/YY" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('OpenBSD')
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
-      resource[:expiry] = "1997-06-01"
-      expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', 'June 01 1997', 'myuser'])
-    end
-  end
-
-  describe "#loginclass" do
-    before :each do
-      resource
-    end
-
-    it "should return the loginclass if set", :if => Puppet.features.libshadow? do
-      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
-      provider.send(:loginclass).should == 'staff'
-    end
-
-    it "should return the empty string when loginclass isn't set", :if => Puppet.features.libshadow? do
-      shadow_entry[:sp_loginclass] = ''
-      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
-      provider.send(:loginclass).should == ''
-    end
-
-    it "should return nil when loginclass isn't available", :if => Puppet.features.libshadow? do
-      shadow_entry[:sp_loginclass] = nil
-      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
-      provider.send(:loginclass).should be_nil
-    end
-  end
-end

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

@@ -1,252 +0,0 @@
-require 'spec_helper'
-require 'open3'
-
-RSpec::Matchers.define_negated_matcher :excluding, :include
-
-describe Puppet::Type.type(:user).provider(:pw) do
-  let :resource do
-    Puppet::Type.type(:user).new(:name => "testuser", :provider => :pw)
-  end
-
-  context "when creating users" do
-    let :provider do
-      prov = resource.provider
-      expect(prov).to receive(:exists?).and_return(nil)
-      prov
-    end
-
-    it "should run pw with no additional flags when no properties are given" do
-      expect(provider.addcmd).to eq([described_class.command(:pw), "useradd", "testuser"])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "useradd", "testuser"], kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -o when allowdupe is enabled" do
-      resource[:allowdupe] = true
-      expect(provider).to receive(:execute).with(include("-o"), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -c with the correct argument when the comment property is set" do
-      resource[:comment] = "Testuser Name"
-      expect(provider).to receive(:execute).with(include("-c").and(include("Testuser Name")), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -e with the correct argument when the expiry property is set" do
-      resource[:expiry] = "2010-02-19"
-      expect(provider).to receive(:execute).with(include("-e").and(include("19-02-2010")), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -e 00-00-0000 if the expiry property has to be removed" do
-      resource[:expiry] = :absent
-      expect(provider).to receive(:execute).with(include("-e").and(include("00-00-0000")), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -g with the correct argument when the gid property is set" do
-      resource[:gid] = 12345
-      expect(provider).to receive(:execute).with(include("-g").and(include(12345)), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -G with the correct argument when the groups property is set" do
-      resource[:groups] = "group1"
-      allow(Puppet::Util::POSIX).to receive(:groups_of).with('testuser').and_return([])
-      expect(provider).to receive(:execute).with(include("-G").and(include("group1")), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -G with all the given groups when the groups property is set to an array" do
-      resource[:groups] = ["group1", "group2"]
-      allow(Puppet::Util::POSIX).to receive(:groups_of).with('testuser').and_return([])
-      expect(provider).to receive(:execute).with(include("-G").and(include("group1,group2")), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -d with the correct argument when the home property is set" do
-      resource[:home] = "/home/testuser"
-      expect(provider).to receive(:execute).with(include("-d").and(include("/home/testuser")), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -m when the managehome property is enabled" do
-      resource[:managehome] = true
-      expect(provider).to receive(:execute).with(include("-m"), kind_of(Hash))
-      provider.create
-    end
-
-    it "should call the password set function with the correct argument when the password property is set" do
-      resource[:password] = "*"
-      expect(provider).to receive(:execute)
-      expect(provider).to receive(:password=).with("*")
-      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))
-      provider.create
-    end
-
-    it "should use -u with the correct argument when the uid property is set" do
-      resource[:uid] = 12345
-      expect(provider).to receive(:execute).with(include("-u").and(include(12345)), kind_of(Hash))
-      provider.create
-    end
-
-    # (#7500) -p should not be used to set a password (it means something else)
-    it "should not use -p when a password is given" do
-      resource[:password] = "*"
-      expect(provider.addcmd).not_to include("-p")
-      expect(provider).to receive(:password=)
-      expect(provider).to receive(:execute).with(excluding("-p"), kind_of(Hash))
-      provider.create
-    end
-  end
-
-  context "when deleting users" do
-    it "should run pw with no additional flags" do
-      provider = resource.provider
-      expect(provider).to receive(:exists?).and_return(true)
-      expect(provider.deletecmd).to eq([described_class.command(:pw), "userdel", "testuser"])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "userdel", "testuser"], hash_including(custom_environment: {}))
-      provider.delete
-    end
-
-    # The above test covers this, but given the consequences of
-    # accidentally deleting a user's home directory it seems better to
-    # have an explicit test.
-    it "should not use -r when managehome is not set" do
-      provider = resource.provider
-      expect(provider).to receive(:exists?).and_return(true)
-      resource[:managehome] = false
-      expect(provider).to receive(:execute).with(excluding("-r"), hash_including(custom_environment: {}))
-      provider.delete
-    end
-
-    it "should use -r when managehome is set" do
-      provider = resource.provider
-      expect(provider).to receive(:exists?).and_return(true)
-      resource[:managehome] = true
-      expect(provider).to receive(:execute).with(include("-r"), hash_including(custom_environment: {}))
-      provider.delete
-    end
-  end
-
-  context "when modifying users" do
-    let :provider do
-      resource.provider
-    end
-
-    it "should run pw with the correct arguments" do
-      expect(provider.modifycmd("uid", 12345)).to eq([described_class.command(:pw), "usermod", "testuser", "-u", 12345])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "usermod", "testuser", "-u", 12345], hash_including(custom_environment: {}))
-      provider.uid = 12345
-    end
-
-    it "should use -c with the correct argument when the comment property is changed" do
-      resource[:comment] = "Testuser Name"
-      expect(provider).to receive(:execute).with(include("-c").and(include("Testuser New Name")), hash_including(custom_environment: {}))
-      provider.comment = "Testuser New Name"
-    end
-
-    it "should use -e with the correct argument when the expiry property is changed" do
-      resource[:expiry] = "2010-02-19"
-      expect(provider).to receive(:execute).with(include("-e").and(include("19-02-2011")), hash_including(custom_environment: {}))
-      provider.expiry = "2011-02-19"
-    end
-
-    it "should use -e with the correct argument when the expiry property is removed" do
-      resource[:expiry] = :absent
-      expect(provider).to receive(:execute).with(include("-e").and(include("00-00-0000")), hash_including(custom_environment: {}))
-      provider.expiry = :absent
-    end
-
-    it "should use -g with the correct argument when the gid property is changed" do
-      resource[:gid] = 12345
-      expect(provider).to receive(:execute).with(include("-g").and(include(54321)), hash_including(custom_environment: {}))
-      provider.gid = 54321
-    end
-
-    it "should use -G with the correct argument when the groups property is changed" do
-      resource[:groups] = "group1"
-      expect(provider).to receive(:execute).with(include("-G").and(include("group2")), hash_including(custom_environment: {}))
-      provider.groups = "group2"
-    end
-
-    it "should use -G with all the given groups when the groups property is changed with an array" do
-      resource[:groups] = ["group1", "group2"]
-      expect(provider).to receive(:execute).with(include("-G").and(include("group3,group4")), hash_including(custom_environment: {}))
-      provider.groups = "group3,group4"
-    end
-
-    it "should use -d with the correct argument when the home property is changed" do
-      resource[:home] = "/home/testuser"
-      expect(provider).to receive(:execute).with(include("-d").and(include("/newhome/testuser")), hash_including(custom_environment: {}))
-      provider.home = "/newhome/testuser"
-    end
-
-    it "should use -m and -d with the correct argument when the home property is changed and managehome is enabled" do
-      resource[:home] = "/home/testuser"
-      resource[:managehome] = true
-      expect(provider).to receive(:execute).with(include("-d").and(include("/newhome/testuser")).and(include("-m")), hash_including(custom_environment: {}))
-      provider.home = "/newhome/testuser"
-    end
-
-    it "should call the password set function with the correct argument when the password property is changed" do
-      resource[:password] = "*"
-      expect(provider).to receive(:password=).with("!")
-      provider.password = "!"
-    end
-
-    it "should use -s with the correct argument when the shell property is changed" do
-      resource[:shell] = "/bin/sh"
-      expect(provider).to receive(:execute).with(include("-s").and(include("/bin/tcsh")), hash_including(custom_environment: {}))
-      provider.shell = "/bin/tcsh"
-    end
-
-    it "should use -u with the correct argument when the uid property is changed" do
-      resource[:uid] = 12345
-      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