puppet 6.0.0 → 6.1.0

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

@@ -143,13 +143,12 @@ describe 'The Task Type' do
             expect(task_t.instance?(task)).to be_truthy
             expect(task.name).to eq('testmodule::hello')
             expect(task._pcore_type).to eq(task_t)
-            expect(task.supports_noop).to eql(true)
-            expect(task.puppet_task_version).to eql(1)
-            expect(task.implementations).to eql([{"name" => "hello.rb", "path" => "#{modules_dir}/testmodule/tasks/hello.rb", "requirements" => []}])
+            expect(task.metadata['supports_noop']).to eql(true)
+            expect(task.metadata['puppet_task_version']).to eql(1)
+            expect(task.files).to eql([{"name" => "hello.rb", "path" => "#{modules_dir}/testmodule/tasks/hello.rb"}])
 
-            tp = task.parameters
-            expect(tp['message']['description']).to eql('the message')
-            expect(tp['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+            expect(task.metadata['parameters']['message']['description']).to eql('the message')
+            expect(task.parameters['message']).to be_a(Puppet::Pops::Types::PStringType)
           end
         end
 
@@ -157,8 +156,7 @@ describe 'The Task Type' do
           compile do
             task = module_loader.load(:task, 'testmodule::non_data')
             expect(task_t.instance?(task)).to be_truthy
-            tp = task.parameters
-            expect(tp['arg']['type']).to be_a(Puppet::Pops::Types::PHashType)
+            expect(task.parameters['arg']).to be_a(Puppet::Pops::Types::PHashType)
           end
         end
 
@@ -173,7 +171,9 @@ describe 'The Task Type' do
 
           it 'fails to load the task' do
             compile do
-              expect { module_loader.load(:task, 'testmodule') }.to raise_error(ArgumentError, /No source besides task metadata was found/)
+              expect {
+                module_loader.load(:task, 'testmodule')
+              }.to raise_error(Puppet::Module::Task::InvalidTask, /No source besides task metadata was found/)
             end
           end
         end
@@ -192,7 +192,9 @@ describe 'The Task Type' do
 
           it "fails if metadata doesn't specify implementations" do
             compile do
-              expect { module_loader.load(:task, 'testmodule') }.to raise_error(ArgumentError, /Multiple executables were found .*/)
+              expect {
+                module_loader.load(:task, 'testmodule')
+              }.to raise_error(Puppet::Module::Task::InvalidTask, /Multiple executables were found .*/)
             end
           end
 
@@ -204,9 +206,13 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([
-                {"name" => "init.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh", "requirements" => ['shell']},
-                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1", "requirements" => ['powershell']}
+              expect(task.files).to eql([
+                {"name" => "init.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh"},
+                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1"}
+              ])
+              expect(task.metadata['implementations']).to eql([
+                {"name" => "init.sh", "requirements" => ['shell']},
+                {"name" => "init.ps1", "requirements" => ['powershell']}
               ])
             end
           end
@@ -218,21 +224,11 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([
-                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1", "requirements" => ['powershell']}
+              expect(task.files).to eql([
+                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1"}
               ])
-            end
-          end
-
-          it "adds an empty requirements list if one is not specified" do
-            impls = [{'name' => 'init.ps1'}]
-            metadata.replace({'implementations' => impls}.to_json)
-
-            compile do
-              task = module_loader.load(:task, 'testmodule')
-              expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([
-                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1", "requirements" => []}
+              expect(task.metadata['implementations']).to eql([
+                {"name" => "init.ps1", "requirements" => ['powershell']}
               ])
             end
           end
@@ -244,7 +240,9 @@ describe 'The Task Type' do
             metadata.replace({'implementations' => impls}.to_json)
 
             compile do
-              expect { module_loader.load(:task, 'testmodule') }.to raise_error(ArgumentError, /Task metadata for task testmodule specifies missing implementation init\.rb/)
+              expect {
+                module_loader.load(:task, 'testmodule')
+              }.to raise_error(Puppet::Module::Task::InvalidTask, /Task metadata for task testmodule specifies missing implementation init\.rb/)
             end
           end
 
@@ -252,7 +250,9 @@ describe 'The Task Type' do
             metadata.replace({'implementations' => {'init.rb' => []}}.to_json)
 
             compile do
-              expect { module_loader.load(:task, 'testmodule') }.to raise_error(Puppet::ParseError, /Task initializer has wrong type/)
+              expect {
+                module_loader.load(:task, 'testmodule')
+              }.to raise_error(Puppet::Module::Task::InvalidMetadata, /Task metadata for task testmodule does not specify implementations as an array/)
             end
           end
         end
@@ -283,16 +283,18 @@ describe 'The Task Type' do
 
             compile do
               task = module_loader.load(:task, 'testmodule::bar')
-              expect(task.implementations).to eql([
-                {'name' => 'foo.sh', 'path' => "#{modules_dir}/testmodule/tasks/foo.sh", 'requirements' => ['shell']},
-                {'name' => 'foo.ps1', 'path' => "#{modules_dir}/testmodule/tasks/foo.ps1", 'requirements' => ['powershell']},
+              expect(task.files).to eql([
+                {'name' => 'foo.sh', 'path' => "#{modules_dir}/testmodule/tasks/foo.sh"},
+                {'name' => 'foo.ps1', 'path' => "#{modules_dir}/testmodule/tasks/foo.ps1"},
               ])
             end
           end
 
           it 'fails to load the task if it has no implementations section and no associated executables' do
             compile do
-              expect { module_loader.load(:task, 'testmodule::bar') }.to raise_error(ArgumentError, /No source besides task metadata was found/)
+              expect {
+                module_loader.load(:task, 'testmodule::bar')
+              }.to raise_error(Puppet::Module::Task::InvalidTask, /No source besides task metadata was found/)
             end
           end
 
@@ -327,9 +329,9 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([{"name" => "init.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh", "requirements" => []}])
-              expect(task.parameters).to be_a(Hash)
-              expect(task.parameters['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+              expect(task.files).to eql([{"name" => "init.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh"}])
+              expect(task.metadata['parameters']).to be_a(Hash)
+              expect(task.parameters['message']).to be_a(Puppet::Pops::Types::PStringType)
             end
           end
         end
@@ -358,9 +360,9 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule::hello')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([{"name" => "hello.sh", "path" => "#{modules_dir}/testmodule/tasks/hello.sh", "requirements" => []}])
-              expect(task.parameters).to be_a(Hash)
-              expect(task.parameters['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+              expect(task.files).to eql([{"name" => "hello.sh", "path" => "#{modules_dir}/testmodule/tasks/hello.sh"}])
+              expect(task.metadata['parameters']).to be_a(Hash)
+              expect(task.parameters['message']).to be_a(Puppet::Pops::Types::PStringType)
             end
           end
         end
@@ -383,31 +385,6 @@ describe 'The Task Type' do
           end
         end
 
-        context 'that has a malformed top-level entry' do
-          let(:testmodule) {
-            {
-              'tasks' => {
-                'hello' => 'echo hello',
-                'hello.json' => <<-JSON
-                {
-                  "supports_nop": true,
-                  "parameters": {
-                     "message": { "type": "String" }
-                  }
-                }
-              JSON
-              }
-            }
-          }
-
-          it 'fails with unrecognized key error' do
-            compile do
-              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
-                /Failed to load metadata for task testmodule::hello:.*unrecognized key 'supports_nop'/)
-            end
-          end
-        end
-
         context 'that has no parameters' do
           let(:testmodule) {
             {
@@ -421,58 +398,7 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule::hello')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.parameters).to be_nil
-            end
-          end
-        end
-
-        context 'that has a malformed parameter name' do
-          let(:testmodule) {
-            {
-              'tasks' => {
-                'hello' => 'echo hello',
-                'hello.json' => <<-JSON
-                {
-                  "supports_noop": true,
-                  "parameters": {
-                     "Message": { "type": "String" }
-                  }
-                }
-              JSON
-              }
-            }
-          }
-
-          it 'fails with pattern mismatch error' do
-            compile do
-              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
-                /entry 'parameters' key of entry 'Message' expects a match for Pattern\[\/\\A\[a-z\]\[a-z0-9_\]\*\\z\/\], got 'Message'/)
-            end
-          end
-        end
-
-        context 'that has a puppet_task_version that is a string' do
-          let(:testmodule) {
-            {
-              'tasks' => {
-                'hello' => 'echo hello',
-                'hello.json' => <<-JSON
-                {
-                  "puppet_task_version": "1",
-                  "supports_noop": true,
-                  "parameters": {
-                     "message": { "type": "String" }
-                  }
-                }
-              JSON
-              }
-            }
-          }
-
-          it 'fails with type mismatch error' do
-            compile do
-              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
-                /entry 'puppet_task_version' expects an Integer value, got String/)
+              expect(task.metadata['parameters']).to be_nil
             end
           end
         end

data/spec/unit/pops/validator/validator_spec.rb

@@ -23,7 +23,11 @@ describe "validating 4x" do
 
   def with_environment(environment, env_params = {})
     override_env = environment
-    override_env = environment.override_with(env_params) if env_params.count > 0
+    override_env = environment.override_with({
+      modulepath:     env_params[:modulepath]     || environment.full_modulepath,
+      manifest:       env_params[:manifest]       || environment.manifest,
+      config_version: env_params[:config_version] || environment.config_version
+    }) if env_params.count > 0
     Puppet.override(current_environment: override_env) do
       yield
     end
@@ -72,15 +76,6 @@ describe "validating 4x" do
     end
   end
 
-  it 'should not raise error for legal definition locations' do
-    with_environment(environment, :manifest => 'a/manifest/file.pp') do
-      expect(validate(parse('function aaa::bbb() {}',      'path/aaa/manifests/bbb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('class aaa() {}',      'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('function aaa::bbB::ccc() {}', 'path/aaa/manifests/bBb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('function aaa::bbb::ccc() {}', 'path/aaa/manifests/bbb/CCC.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-    end
-  end
-
   it 'should not raise error for definitions inside initial --manifest file' do
     with_environment(environment, :manifest => 'a/manifest/file.pp') do
       expect(validate(parse('class aaa() {}', 'a/manifest/file.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
@@ -100,6 +95,13 @@ describe "validating 4x" do
     end
   end
 
+  it 'should not raise error for empty files in modulepath' do
+    with_environment(environment) do
+      expect(validate(parse('', 'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+      expect(validate(parse('#this is a comment', 'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+    end
+  end
+
   it 'should raise error if the file is in the modulepath but is not well formed' do
     with_environment(environment) do
       expect(validate(parse('class aaa::bbb::ccc() {}', 'path/manifest/aaa/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
@@ -113,6 +115,18 @@ describe "validating 4x" do
     end
   end
 
+  it 'should not raise error when one modulepath is a substring of another' do
+    with_environment(environment, modulepath: ['path', 'pathplus']) do
+      expect(validate(parse('class aaa::ccc() {}', 'pathplus/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error when a modulepath ends with a file separator' do
+    with_environment(environment, modulepath: ['path/']) do
+      expect(validate(parse('class aaa::ccc() {}', 'pathplus/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
   it 'should raise error for illegal type names' do
     expect(validate(parse('type ::Aaa = Any'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
   end

data/spec/unit/provider/exec/posix_spec.rb

@@ -117,6 +117,30 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       expect(@logs.map {|l| "#{l.level}: #{l.message}" }).to eq(["warning: Overriding environment setting 'WHATEVER' with '/foo'"])
     end
 
+    it "should warn when setting an empty environment variable" do
+      provider.resource[:environment] = ['WHATEVER=']
+      command = make_exe
+
+      Puppet::Util::Execution.expects(:execute).with(command, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
+      provider.run(command)
+
+      expect(@logs.map(&:to_s).join).to match(/Empty environment setting 'WHATEVER'\n\s+\(file & line not available\)/m)
+    end
+
+    it "should warn when setting an empty environment variable (within a manifest)" do
+      provider.resource[:environment] = ['WHATEVER=']
+      provider.resource.file = '/tmp/foobar'
+      provider.resource.line = 42
+      command = make_exe
+
+      Puppet::Util::Execution.expects(:execute).with(command, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
+      provider.run(command)
+
+      expect(@logs.map(&:to_s).join).to match(/Empty environment setting 'WHATEVER'\n\s+\(file: \/tmp\/foobar, line: 42\)/m)
+    end
+
     it "should set umask before execution if umask parameter is in use" do
       provider.resource[:umask] = '0027'
       Puppet::Util.expects(:withumask).with(0027)

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

@@ -63,14 +63,28 @@ describe 'Puppet::Type::Group::Provider::Aix' do
   end
 
   describe '.members_to_users' do
-    it 'returns the members property as-is if it is not an Array' do
-      expect(provider_class.members_to_users('members'))
-        .to eql('members')
+    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
 
-    it 'returns the members property as a comma-separated string if it is an Array' do
-      expect(provider_class.members_to_users(['user1', 'user2']))
-        .to eql('user1,user2')
+    context 'when auth_membership == false' do
+      before(:each) do
+        resource[:auth_membership] = false
+
+        provider.stubs(:members).returns(['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/ldap_spec.rb

@@ -1,54 +1,51 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:group).provider(:ldap)
-
-describe provider_class do
+describe Puppet::Type.type(:group).provider(:ldap) do
   it "should have the Ldap provider class as its baseclass" do
-    expect(provider_class.superclass).to equal(Puppet::Provider::Ldap)
+    expect(described_class.superclass).to equal(Puppet::Provider::Ldap)
   end
 
   it "should manage :posixGroup objectclass" do
-    expect(provider_class.manager.objectclasses).to eq([:posixGroup])
+    expect(described_class.manager.objectclasses).to eq([:posixGroup])
   end
 
   it "should use 'ou=Groups' as its relative base" do
-    expect(provider_class.manager.location).to eq("ou=Groups")
+    expect(described_class.manager.location).to eq("ou=Groups")
   end
 
   it "should use :cn as its rdn" do
-    expect(provider_class.manager.rdn).to eq(:cn)
+    expect(described_class.manager.rdn).to eq(:cn)
   end
 
   it "should map :name to 'cn'" do
-    expect(provider_class.manager.ldap_name(:name)).to eq('cn')
+    expect(described_class.manager.ldap_name(:name)).to eq('cn')
   end
 
   it "should map :gid to 'gidNumber'" do
-    expect(provider_class.manager.ldap_name(:gid)).to eq('gidNumber')
+    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(provider_class.manager.ldap_name(:members)).to eq('memberUid')
+    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 = mock 'connection'
-      provider_class.manager.stubs(:connect).yields @connection
+      described_class.manager.stubs(:connect).yields @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"]}
-        provider_class.manager.expects(:search).returns([low, high])
+        described_class.manager.expects(:search).returns([low, high])
 
         resource = stub 'resource', :should => %w{whatever}
         resource.stubs(:should).with(:gid).returns nil
         resource.stubs(:should).with(:ensure).returns :present
-        instance = provider_class.new(:name => "luke", :ensure => :absent)
+        instance = described_class.new(:name => "luke", :ensure => :absent)
         instance.stubs(:resource).returns resource
 
         @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["641"] }
@@ -58,12 +55,12 @@ describe provider_class do
       end
 
       it "should pick '501' as its GID if no groups are found" do
-        provider_class.manager.expects(:search).returns nil
+        described_class.manager.expects(:search).returns nil
 
         resource = stub 'resource', :should => %w{whatever}
         resource.stubs(:should).with(:gid).returns nil
         resource.stubs(:should).with(:ensure).returns :present
-        instance = provider_class.new(:name => "luke", :ensure => :absent)
+        instance = described_class.new(:name => "luke", :ensure => :absent)
         instance.stubs(:resource).returns resource
 
         @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["501"] }
@@ -75,27 +72,27 @@ describe provider_class do
   end
 
   it "should have a method for converting group names to GIDs" do
-    expect(provider_class).to respond_to(:name2id)
+    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
-      provider_class.manager.expects(:search).with("cn=foo")
-      provider_class.name2id("foo")
+      described_class.manager.expects(:search).with("cn=foo")
+      described_class.name2id("foo")
     end
 
     it "should return nil if no group is found" do
-      provider_class.manager.expects(:search).with("cn=foo").returns nil
-      expect(provider_class.name2id("foo")).to be_nil
-      provider_class.manager.expects(:search).with("cn=bar").returns []
-      expect(provider_class.name2id("bar")).to be_nil
+      described_class.manager.expects(:search).with("cn=foo").returns nil
+      expect(described_class.name2id("foo")).to be_nil
+      described_class.manager.expects(:search).with("cn=bar").returns []
+      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
-      provider_class.manager.expects(:search).with("cn=foo").returns [{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}]
-      expect(provider_class.name2id("foo")).to eq(10)
+      described_class.manager.expects(:search).with("cn=foo").returns [{: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,9 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:group).provider(:pw)
-
-describe provider_class do
+describe Puppet::Type.type(:group).provider(:pw) do
   let :resource do
     Puppet::Type.type(:group).new(:name => "testgroup", :provider => :pw)
   end
@@ -20,8 +17,8 @@ describe provider_class do
     end
 
     it "should run pw with no additional flags when no properties are given" do
-      expect(provider.addcmd).to eq([provider_class.command(:pw), "groupadd", "testgroup"])
-      provider.expects(:execute).with([provider_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
+      expect(provider.addcmd).to eq([described_class.command(:pw), "groupadd", "testgroup"])
+      provider.expects(:execute).with([described_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
       provider.create
     end
 
@@ -53,16 +50,16 @@ describe provider_class do
   describe "when deleting groups" do
     it "should run pw with no additional flags" do
       provider.expects(:exists?).returns true
-      expect(provider.deletecmd).to eq([provider_class.command(:pw), "groupdel", "testgroup"])
-      provider.expects(:execute).with([provider_class.command(:pw), "groupdel", "testgroup"], has_entry(:custom_environment, {}))
+      expect(provider.deletecmd).to eq([described_class.command(:pw), "groupdel", "testgroup"])
+      provider.expects(:execute).with([described_class.command(:pw), "groupdel", "testgroup"], has_entry(: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([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
-      provider.expects(:execute).with([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345], has_entry(:custom_environment, {}))
+      expect(provider.modifycmd("gid", 12345)).to eq([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
+      provider.expects(:execute).with([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345], has_entry(:custom_environment, {}))
       provider.gid = 12345
     end