puppet 7.28.0 → 7.29.1

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

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Group::Provider::Aix' do
-  let(:provider_class) { Puppet::Type.type(:group).provider(:aix) }
-
-  let(:resource) do
-    Puppet::Type.type(:group).new(
-      :name   => 'test_aix_user',
-      :ensure => :present
-    )
-  end
-
-  let(:provider) do
-    provider_class.new(resource)
-  end
-
-  describe '.find' do
-    let(:groups) do
-      objects = [
-        { :name => 'group1', :id => '1' },
-        { :name => 'group2', :id => '2' }
-      ]
-
-      objects
-    end
-
-    let(:ia_module_args) { [ '-R', 'module' ] }
-
-    let(:expected_group) do
-      {
-        :name => 'group1',
-        :gid  => 1
-      }
-    end
-
-    before(:each) do
-      allow(provider_class).to receive(:list_all).with(ia_module_args).and_return(groups)
-    end
-
-    it 'raises an ArgumentError if the group does not exist' do
-      expect do
-        provider_class.find('non_existent_group', ia_module_args)
-      end.to raise_error do |error|
-        expect(error).to be_a(ArgumentError)
-
-        expect(error.message).to match('non_existent_group')
-      end
-    end
-
-    it 'can find the group when passed-in a group name' do
-      expect(provider_class.find('group1', ia_module_args)).to eql(expected_group)
-    end
-
-    it 'can find the group when passed-in the gid' do
-      expect(provider_class.find(1, ia_module_args)).to eql(expected_group)
-    end
-  end
-
-  describe '.users_to_members' do
-    it 'converts the users attribute to the members property' do
-      expect(provider_class.users_to_members('foo,bar'))
-        .to eql(['foo', 'bar'])
-    end
-  end
-
-  describe '.members_to_users' do
-    context 'when auth_membership == true' do
-      before(:each) do
-        resource[:auth_membership] = true
-      end
-
-      it 'returns only the passed-in members' do
-        expect(provider_class.members_to_users(provider, ['user1', 'user2']))
-          .to eql('user1,user2')
-      end
-    end
-
-    context 'when auth_membership == false' do
-      before(:each) do
-        resource[:auth_membership] = false
-
-        allow(provider).to receive(:members).and_return(['user3', 'user1'])
-      end
-
-      it 'adds the passed-in members to the current list of members, filtering out any duplicates' do
-        expect(provider_class.members_to_users(provider, ['user1', 'user2']))
-          .to eql('user1,user2,user3')
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:group).provider(:directoryservice) do
-  let :resource do
-    Puppet::Type.type(:group).new(
-      :title => 'testgroup',
-      :provider => :directoryservice,
-    )
-  end
-
-  let(:provider) { resource.provider }
-
-  it 'should return true for same lists of unordered members' do
-    expect(provider.members_insync?(['user1', 'user2'], ['user2', 'user1'])).to be_truthy
-  end
-
-  it 'should return false when the group currently has no members' do
-    expect(provider.members_insync?([], ['user2', 'user1'])).to be_falsey
-  end
-
-  it 'should return true for the same lists of members irrespective of duplicates' do
-    expect(provider.members_insync?(['user1', 'user2', 'user2'], ['user1', 'user2'])).to be_truthy
-  end
-
-  it "should return true when current and should members are empty lists" do
-    expect(provider.members_insync?([], [])).to be_truthy
-  end
-
-  it "should return true when current is :absent and should members is empty list" do
-    expect(provider.members_insync?(:absent, [])).to be_truthy
-  end
-
-end

data/spec/unit/provider/group/groupadd_spec.rb

@@ -1,284 +0,0 @@
-require 'spec_helper'
-
-RSpec::Matchers.define_negated_matcher :excluding, :include
-
-describe Puppet::Type.type(:group).provider(:groupadd) do
-  before do
-    allow(described_class).to receive(:command).with(:add).and_return('/usr/sbin/groupadd')
-    allow(described_class).to receive(:command).with(:delete).and_return('/usr/sbin/groupdel')
-    allow(described_class).to receive(:command).with(:modify).and_return('/usr/sbin/groupmod')
-    allow(described_class).to receive(:command).with(:localadd).and_return('/usr/sbin/lgroupadd')
-    allow(described_class).to receive(:command).with(:localdelete).and_return('/usr/sbin/lgroupdel')
-    allow(described_class).to receive(:command).with(:localmodify).and_return('/usr/sbin/lgroupmod')
-  end
-
-  let(:resource) { Puppet::Type.type(:group).new(:name => 'mygroup', :provider => provider) }
-  let(:provider) { described_class.new(:name => 'mygroup') }
-  let(:members) { ['user2', 'user1', 'user3'] }
-
-  describe "#create" do
-    before do
-      allow(provider).to receive(:exists?).and_return(false)
-    end
-
-    it "should add -o when allowdupe is enabled and the group is being created" do
-      resource[:allowdupe] = :true
-      expect(provider).to receive(:execute).with(['/usr/sbin/groupadd', '-o', 'mygroup'], kind_of(Hash))
-      provider.create
-    end
-
-    describe "on system that feature system_groups", :if => described_class.system_groups? do
-      it "should add -r when system is enabled and the group is being created" do
-        resource[:system] = :true
-        expect(provider).to receive(:execute).with(['/usr/sbin/groupadd', '-r', 'mygroup'], kind_of(Hash))
-        provider.create
-      end
-    end
-
-    describe "on system that do not feature system_groups", :unless => described_class.system_groups? do
-      it "should not add -r when system is enabled and the group is being created" do
-        resource[:system] = :true
-        expect(provider).to receive(:execute).with(['/usr/sbin/groupadd', 'mygroup'], kind_of(Hash))
-        provider.create
-      end
-    end
-
-    describe "on systems with libuser" do
-      describe "with forcelocal=true" do
-        before do
-          described_class.has_feature(:manages_local_users_and_groups)
-          resource[:forcelocal] = :true
-        end
-
-        it "should use lgroupadd instead of groupadd" do
-          expect(provider).to receive(:execute).with(including('/usr/sbin/lgroupadd'), hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
-          provider.create
-        end
-
-        it "should NOT pass -o to lgroupadd" do
-          resource[:allowdupe] = :true
-          expect(provider).to receive(:execute).with(excluding('-o'), hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
-          provider.create
-        end
-
-        it "should raise an exception for duplicate GID if allowdupe is not set and duplicate GIDs exist" do
-          resource[:gid] = 505
-          allow(provider).to receive(:findgroup).and_return(true)
-          expect { provider.create }.to raise_error(Puppet::Error, "GID 505 already exists, use allowdupe to force group creation")
-        end
-      end
-
-      describe "with a list of members" do
-        before do
-          members.each { |m| allow(Etc).to receive(:getpwnam).with(m).and_return(true) }
-
-          described_class.has_feature(:manages_members)
-          resource[:forcelocal] = false
-          resource[:members] = members
-        end
-
-        it "should use lgroupmod to add the members" do
-          allow(provider).to receive(:execute).with(['/usr/sbin/groupadd', 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}})).and_return(true)
-          expect(provider).to receive(:execute).with(['/usr/sbin/lgroupmod', '-M', members.join(','), 'mygroup'], hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
-          provider.create
-        end
-      end
-    end
-  end
-
-  describe "#modify" do
-    before do
-      allow(provider).to receive(:exists?).and_return(true)
-    end
-
-    describe "on systems with libuser" do
-      describe "with forcelocal=false" do
-        before do
-          described_class.has_feature(:manages_local_users_and_groups)
-          resource[:forcelocal] = :false
-        end
-
-        it "should use groupmod" do
-          expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
-          provider.gid = 150
-        end
-
-        it "should pass -o to groupmod" do
-          resource[:allowdupe] = :true
-          expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
-          provider.gid = 150
-        end
-      end
-
-      describe "with forcelocal=true" do
-        before do
-          described_class.has_feature(:manages_local_users_and_groups)
-          resource[:forcelocal] = :true
-        end
-
-        it "should use lgroupmod instead of groupmod" do
-          expect(provider).to receive(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
-          provider.gid = 150
-        end
-
-        it "should NOT pass -o to lgroupmod" do
-          resource[:allowdupe] = :true
-          expect(provider).to receive(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
-          provider.gid = 150
-        end
-
-        it "should raise an exception for duplicate GID if allowdupe is not set and duplicate GIDs exist" do
-          resource[:gid] = 150
-          resource[:allowdupe] = :false
-          allow(provider).to receive(:findgroup).and_return(true)
-          expect { provider.gid = 150 }.to raise_error(Puppet::Error, "GID 150 already exists, use allowdupe to force group creation")
-        end
-      end
-
-      describe "with members=something" do
-        before do
-          described_class.has_feature(:manages_members)
-          allow(Etc).to receive(:getpwnam).and_return(true)
-          resource[:members] = members
-        end
-
-        describe "with auth_membership on" do
-          before { resource[:auth_membership] = true }
-
-          it "should purge existing users before adding" do
-            allow(provider).to receive(:members).and_return(members)
-            expect(provider).to receive(:localmodify).with('-m', members.join(','), 'mygroup')
-            provider.modifycmd(:members, ['user1'])
-          end
-        end
-
-        describe "with auth_membership off" do
-          before { resource[:auth_membership] = false }
-
-          it "should add to the existing users" do
-            new_members = ['user1', 'user2', 'user3', 'user4']
-            allow(provider).to receive(:members).and_return(members)
-            expect(provider).not_to receive(:localmodify).with('-m', members.join(','), 'mygroup')
-            expect(provider).to receive(:execute).with(['/usr/sbin/lgroupmod', '-M', new_members.join(','), 'mygroup'], kind_of(Hash))
-            provider.members = new_members
-          end
-        end
-
-        it "should validate members" do
-          expect(Etc).to receive(:getpwnam).with('user3').and_return(true)
-          provider.modifycmd(:members, ['user3'])
-        end
-
-        it "should validate members list " do
-          expect(Etc).to receive(:getpwnam).with('user3').and_return(true)
-          expect(Etc).to receive(:getpwnam).with('user4').and_return(true)
-          provider.modifycmd(:members, ['user3', 'user4'])
-        end
-
-        it "should validate members list separated by commas" do
-          expect(Etc).to receive(:getpwnam).with('user3').and_return(true)
-          expect(Etc).to receive(:getpwnam).with('user4').and_return(true)
-          provider.modifycmd(:members, ['user3, user4'])
-        end
-
-        it "should raise is validation fails" do
-          expect(Etc).to receive(:getpwnam).with('user3').and_throw(ArgumentError)
-          expect { provider.modifycmd(:members, ['user3']) }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-
-  describe "#gid=" do
-    it "should add -o when allowdupe is enabled and the gid is being modified" do
-      resource[:allowdupe] = :true
-      expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
-      provider.gid = 150
-    end
-  end
-
-  describe "#findgroup" do
-    before do
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/group').and_return(true)
-      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/group').and_yield(content)
-    end
-
-    let(:content) { "sample_group_name:sample_password:sample_gid:sample_user_list" }
-    let(:output) do
-      {
-        group_name: 'sample_group_name',
-        password: 'sample_password',
-        gid: 'sample_gid',
-        user_list: 'sample_user_list',
-      }
-    end
-
-    [:group_name, :password, :gid, :user_list].each do |key|
-      it "finds a group by #{key} when asked" do
-        expect(provider.send(:findgroup, key, "sample_#{key}")).to eq(output)
-      end
-    end
-
-    it "returns false when specified key/value pair is not found" do
-      expect(provider.send(:findgroup, :group_name, 'invalid_group_name')).to eq(false)
-    end
-
-    it "reads the group file only once per resource" do
-      expect(Puppet::FileSystem).to receive(:each_line).with('/etc/group').once
-      5.times { provider.send(:findgroup, :group_name, 'sample_group_name') }
-    end
-  end
-
-  describe "#delete" do
-    before do
-      allow(provider).to receive(:exists?).and_return(true)
-    end
-
-    describe "on systems with the libuser and forcelocal=false" do
-      before do
-        described_class.has_feature(:manages_local_users_and_groups)
-        resource[:forcelocal] = :false
-      end
-
-      it "should use groupdel" do
-        expect(provider).to receive(:execute).with(['/usr/sbin/groupdel', 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
-        provider.delete
-      end
-    end
-
-    describe "on systems with the libuser and forcelocal=true" do
-      before do
-        described_class.has_feature(:manages_local_users_and_groups)
-        resource[:forcelocal] = :true
-      end
-
-      it "should use lgroupdel instead of groupdel" do
-        expect(provider).to receive(:execute).with(['/usr/sbin/lgroupdel', 'mygroup'], hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
-        provider.delete
-      end
-    end
-  end
-
-  describe "group type :members property helpers" do
-    describe "#members_to_s" do
-      it "should return an empty string on non-array input" do
-        [Object.new, {}, 1, :symbol, ''].each do |input|
-          expect(provider.members_to_s(input)).to be_empty
-        end
-      end
-
-      it "should return an empty string on empty or nil users" do
-        expect(provider.members_to_s([])).to be_empty
-        expect(provider.members_to_s(nil)).to be_empty
-      end
-
-      it "should return a user string for a single user" do
-        expect(provider.members_to_s(['user1'])).to eq('user1')
-      end
-
-      it "should return a user string for multiple users" do
-        expect(provider.members_to_s(['user1', 'user2'])).to eq('user1,user2')
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:group).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 :posixGroup objectclass" do
-    expect(described_class.manager.objectclasses).to eq([:posixGroup])
-  end
-
-  it "should use 'ou=Groups' as its relative base" do
-    expect(described_class.manager.location).to eq("ou=Groups")
-  end
-
-  it "should use :cn as its rdn" do
-    expect(described_class.manager.rdn).to eq(:cn)
-  end
-
-  it "should map :name to 'cn'" do
-    expect(described_class.manager.ldap_name(:name)).to eq('cn')
-  end
-
-  it "should map :gid to 'gidNumber'" do
-    expect(described_class.manager.ldap_name(:gid)).to eq('gidNumber')
-  end
-
-  it "should map :members to 'memberUid', to be used by the user ldap provider" do
-    expect(described_class.manager.ldap_name(:members)).to eq('memberUid')
-  end
-
-  describe "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
-
-    describe "with no gid specified" do
-      it "should pick the first available GID after the largest existing GID" do
-        low = {:name=>["luke"], :gid=>["600"]}
-        high = {:name=>["testing"], :gid=>["640"]}
-        expect(described_class.manager).to receive(:search).and_return([low, high])
-
-        resource = double('resource', :should => %w{whatever})
-        allow(resource).to receive(:should).with(:gid).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("gidNumber" => ["641"]))
-
-        instance.create
-        instance.flush
-      end
-
-      it "should pick '501' as its GID if no groups are found" do
-        expect(described_class.manager).to receive(:search).and_return(nil)
-
-        resource = double('resource', :should => %w{whatever})
-        allow(resource).to receive(:should).with(:gid).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("gidNumber" => ["501"]))
-
-        instance.create
-        instance.flush
-      end
-    end
-  end
-
-  it "should have a method for converting group names to GIDs" do
-    expect(described_class).to respond_to(:name2id)
-  end
-
-  describe "when converting from a group name to GID" do
-    it "should use the ldap manager to look up the GID" do
-      expect(described_class.manager).to receive(:search).with("cn=foo")
-      described_class.name2id("foo")
-    end
-
-    it "should return nil if no group is found" do
-      expect(described_class.manager).to receive(:search).with("cn=foo").and_return(nil)
-      expect(described_class.name2id("foo")).to be_nil
-      expect(described_class.manager).to receive(:search).with("cn=bar").and_return([])
-      expect(described_class.name2id("bar")).to be_nil
-    end
-
-    # We shouldn't ever actually have more than one gid, but it doesn't hurt
-    # to test for the possibility.
-    it "should return the first gid from the first returned group" do
-      expect(described_class.manager).to receive(:search).with("cn=foo").and_return([{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}])
-      expect(described_class.name2id("foo")).to eq(10)
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:group).provider(:pw) do
-  let :resource do
-    Puppet::Type.type(:group).new(:name => "testgroup", :provider => :pw)
-  end
-
-  let :provider do
-    resource.provider
-  end
-
-  describe "when creating groups" 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), "groupadd", "testgroup"])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "groupadd", "testgroup"], 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 -g with the correct argument when the gid property is set" do
-      resource[:gid] = 12345
-      expect(provider).to receive(:execute).with(include("-g") & include(12345), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -M with the correct argument when the members property is set" do
-      resource[:members] = "user1"
-      expect(provider).to receive(:execute).with(include("-M") & include("user1"), kind_of(Hash))
-      provider.create
-    end
-
-    it "should use -M with all the given users when the members property is set to an array" do
-      resource[:members] = ["user1", "user2"]
-      expect(provider).to receive(:execute).with(include("-M") & include("user1,user2"), kind_of(Hash))
-      provider.create
-    end
-  end
-
-  describe "when deleting groups" do
-    it "should run pw with no additional flags" do
-      expect(provider).to receive(:exists?).and_return(true)
-      expect(provider.deletecmd).to eq([described_class.command(:pw), "groupdel", "testgroup"])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "groupdel", "testgroup"], hash_including(:custom_environment => {}))
-      provider.delete
-    end
-  end
-
-  describe "when modifying groups" do
-    it "should run pw with the correct arguments" do
-      expect(provider.modifycmd("gid", 12345)).to eq([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345], hash_including(:custom_environment => {}))
-      provider.gid = 12345
-    end
-
-    it "should use -M with the correct argument when the members property is changed" do
-      resource[:members] = "user1"
-      expect(provider).to receive(:execute).with(include("-M") & include("user2"), hash_including(:custom_environment, {}))
-      provider.members = "user2"
-    end
-
-    it "should use -M with all the given users when the members property is changed with an array" do
-      resource[:members] = ["user1", "user2"]
-      expect(provider).to receive(:execute).with(include("-M") & include("user3,user4"), hash_including(:custom_environment, {}))
-      provider.members = ["user3", "user4"]
-    end
-  end
-end