puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

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

@@ -42,6 +42,13 @@ describe 'The type calculator' do
     TypeFactory.variant(*types)
   end
 
+  def empty_variant_t()
+    t = TypeFactory.variant()
+    # assert this to ensure we did get an empty variant (or tests may pass when not being empty)
+    raise 'typefactory did not return empty variant' unless t.types.empty?
+    t
+  end
+
   def type_alias_t(name, type_string)
     type_expr = Parser::EvaluatingParser.new.parse_string(type_string)
     TypeFactory.type_alias(name, type_expr)
@@ -156,12 +163,12 @@ describe 'The type calculator' do
       expect(t.value).to eq('foo')
     end
 
-    it 'boolean true translates to PBooleanType' do
-      expect(calculator.infer(true).class).to eq(PBooleanType)
+    it 'boolean true translates to PBooleanType::TRUE' do
+      expect(calculator.infer(true)).to eq(PBooleanType::TRUE)
     end
 
-    it 'boolean false translates to PBooleanType' do
-      expect(calculator.infer(false).class).to eq(PBooleanType)
+    it 'boolean false translates to PBooleanType::FALSE' do
+      expect(calculator.infer(false)).to eq(PBooleanType::FALSE)
     end
 
     it 'regexp translates to PRegexpType' do
@@ -851,7 +858,6 @@ describe 'The type calculator' do
         t = PTypeReferenceType::DEFAULT
         all_instances = (all_types - [
           PTypeReferenceType, # Avoid comparison with t
-          PVariantType,   # DEFAULT contains no variants, so assignability is never tested and always true
           PTypeAliasType      # DEFAULT resolves to PTypeReferenceType::DEFAULT, i.e. t
         ]).map {|c| c::DEFAULT }
 
@@ -942,6 +948,45 @@ describe 'The type calculator' do
         expect(v).not_to be_assignable_to(range_t(0, 4))
         expect(v).not_to be_assignable_to(string_t)
       end
+
+      it 'an empty Variant is assignable to another empty Variant' do
+        expect(empty_variant_t).to be_assignable_to(empty_variant_t)
+      end
+
+      it 'an empty Variant is assignable to Any' do
+        expect(empty_variant_t).to be_assignable_to(PAnyType::DEFAULT)
+      end
+
+      it 'an empty Variant is assignable to Unit' do
+        expect(empty_variant_t).to be_assignable_to(PUnitType::DEFAULT)
+      end
+
+      it 'an empty Variant is not assignable to any type except empty Variant, Any, NotUndef, and Unit' do
+        assignables = [PUnitType, PAnyType, PNotUndefType]
+        unassignables = all_types - assignables
+        unassignables.each {|t2| expect(empty_variant_t).not_to be_assignable_to(t2::DEFAULT) }
+        assignables.each   {|t2| expect(empty_variant_t).to be_assignable_to(t2::DEFAULT) }
+      end
+
+      it 'an empty Variant is not assignable to Optional[Any] since it is not assignable to Undef' do
+        opt_any = optional_t(any_t)
+        expect(empty_variant_t).not_to be_assignable_to(opt_any)
+      end
+
+      it 'an Optional[Any] is not assignable to empty Variant' do
+        opt_any = optional_t(any_t)
+        expect(opt_any).not_to be_assignable_to(empty_variant_t)
+      end
+
+      it 'an empty Variant is assignable to NotUndef[Variant] since Variant is not Undef' do
+        not_undef_variant = not_undef_t(empty_variant_t)
+        expect(empty_variant_t).to be_assignable_to(not_undef_variant)
+      end
+
+      it 'a NotUndef[Variant] is assignable to empty Variant' do
+        not_undef_variant = not_undef_t(empty_variant_t)
+        expect(not_undef_variant).to be_assignable_to(empty_variant_t)
+      end
     end
 
     context 'for Scalar, such that' do
@@ -1056,6 +1101,32 @@ describe 'The type calculator' do
       end
     end
 
+    context 'for Enum, such that' do
+      it 'Enum is assignable to an Enum with all contained options' do
+        expect(enum_t('a', 'b')).to be_assignable_to(enum_t('a', 'b', 'c'))
+      end
+
+      it 'Enum is not assignable to an Enum with fewer contained options' do
+        expect(enum_t('a', 'b')).not_to be_assignable_to(enum_t('a'))
+      end
+
+      it 'case insensitive Enum is not assignable to case sensitive Enum' do
+        expect(enum_t('a', 'b', true)).not_to be_assignable_to(enum_t('a', 'b'))
+      end
+
+      it 'case sensitive Enum is assignable to case insensitive Enum' do
+        expect(enum_t('a', 'b')).to be_assignable_to(enum_t('a', 'b', true))
+      end
+
+      it 'case sensitive Enum is not assignable to case sensitive Enum using different case' do
+        expect(enum_t('a', 'b')).not_to be_assignable_to(enum_t('A', 'B'))
+      end
+
+      it 'case sensitive Enum is assignable to case insensitive Enum using different case' do
+        expect(enum_t('a', 'b')).to be_assignable_to(enum_t('A', 'B', true))
+      end
+    end
+
     context 'for Hash, such that' do
       it 'Hash is not assignable to any other Collection type' do
         t = PHashType::DEFAULT

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

@@ -19,7 +19,7 @@ describe 'The type formatter' do
     {
       'true' => true,
       'false' => false,
-      '?' => nil,
+      'undef' => nil,
       '23.4' => 23.4,
       '145' => 145,
       "'string'" => 'string',
@@ -99,6 +99,14 @@ FORMATTED
       expect(s.string(f.boolean)).to eq('Boolean')
     end
 
+    it "should yield 'Boolean[true]' for PBooleanType parameterized with true" do
+      expect(s.string(f.boolean(true))).to eq('Boolean[true]')
+    end
+
+    it "should yield 'Boolean[false]' for PBooleanType parameterized with false" do
+      expect(s.string(f.boolean(false))).to eq('Boolean[false]')
+    end
+
     it "should yield 'Data' for the Data type" do
       expect(s.string(f.data)).to eq('Data')
     end
@@ -112,7 +120,7 @@ FORMATTED
       expect(s.string(f.range(1,1))).to eq('Integer[1, 1]')
       expect(s.string(f.range(1,2))).to eq('Integer[1, 2]')
       expect(s.string(f.range(:default, 2))).to eq('Integer[default, 2]')
-      expect(s.string(f.range(2, :default))).to eq('Integer[2, default]')
+      expect(s.string(f.range(2, :default))).to eq('Integer[2]')
     end
 
     it "should yield 'Float' for PFloatType" do
@@ -142,8 +150,8 @@ FORMATTED
     it "should yield 'String' and from/to for PStringType" do
       expect(s.string(f.string(f.range(1,1)))).to eq('String[1, 1]')
       expect(s.string(f.string(f.range(1,2)))).to eq('String[1, 2]')
-      expect(s.string(f.string(f.range(:default, 2)))).to eq('String[default, 2]')
-      expect(s.string(f.string(f.range(2, :default)))).to eq('String[2, default]')
+      expect(s.string(f.string(f.range(:default, 2)))).to eq('String[0, 2]')
+      expect(s.string(f.string(f.range(2, :default)))).to eq('String[2]')
     end
 
     it "should yield 'Array[Integer]' for PArrayType[PIntegerType]" do
@@ -167,15 +175,15 @@ FORMATTED
     it "should yield 'Collection' and from/to for PCollectionType" do
       expect(s.string(f.collection(f.range(1,1)))).to eq('Collection[1, 1]')
       expect(s.string(f.collection(f.range(1,2)))).to eq('Collection[1, 2]')
-      expect(s.string(f.collection(f.range(:default, 2)))).to eq('Collection[default, 2]')
-      expect(s.string(f.collection(f.range(2, :default)))).to eq('Collection[2, default]')
+      expect(s.string(f.collection(f.range(:default, 2)))).to eq('Collection[0, 2]')
+      expect(s.string(f.collection(f.range(2, :default)))).to eq('Collection[2]')
     end
 
     it "should yield 'Array' and from/to for PArrayType" do
       expect(s.string(f.array_of(f.string, f.range(1,1)))).to eq('Array[String, 1, 1]')
       expect(s.string(f.array_of(f.string, f.range(1,2)))).to eq('Array[String, 1, 2]')
-      expect(s.string(f.array_of(f.string, f.range(:default, 2)))).to eq('Array[String, default, 2]')
-      expect(s.string(f.array_of(f.string, f.range(2, :default)))).to eq('Array[String, 2, default]')
+      expect(s.string(f.array_of(f.string, f.range(:default, 2)))).to eq('Array[String, 0, 2]')
+      expect(s.string(f.array_of(f.string, f.range(2, :default)))).to eq('Array[String, 2]')
     end
 
     it "should yield 'Iterable' for PIterableType" do
@@ -240,7 +248,7 @@ FORMATTED
       expect(s.string(f.tuple(types, f.range(1,1)))).to eq('Tuple[String, 1, 1]')
       expect(s.string(f.tuple(types, f.range(1,2)))).to eq('Tuple[String, 1, 2]')
       expect(s.string(f.tuple(types, f.range(:default, 2)))).to eq('Tuple[String, 0, 2]')
-      expect(s.string(f.tuple(types, f.range(2, :default)))).to eq('Tuple[String, 2, default]')
+      expect(s.string(f.tuple(types, f.range(2, :default)))).to eq('Tuple[String, 2]')
     end
 
     it "should yield 'Struct' and details for PStructType" do
@@ -257,8 +265,8 @@ FORMATTED
     it "should yield 'Hash' and from/to for PHashType" do
       expect(s.string(f.hash_of(f.string, f.string, f.range(1,1)))).to eq('Hash[String, String, 1, 1]')
       expect(s.string(f.hash_of(f.string, f.string, f.range(1,2)))).to eq('Hash[String, String, 1, 2]')
-      expect(s.string(f.hash_of(f.string, f.string, f.range(:default, 2)))).to eq('Hash[String, String, default, 2]')
-      expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2, default]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(:default, 2)))).to eq('Hash[String, String, 0, 2]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2]')
     end
 
     it "should yield 'Hash' for PHashType::DEFAULT" do
@@ -290,6 +298,16 @@ FORMATTED
       expect(s.string(t)).to eq("Enum['a', 'b', 'c']")
     end
 
+    it "should yield 'Enum[s,...]' for a PEnumType[s,...,false]" do
+      t = f.enum('a', 'b', 'c', false)
+      expect(s.string(t)).to eq("Enum['a', 'b', 'c']")
+    end
+
+    it "should yield 'Enum[s,...,true]' for a PEnumType[s,...,true]" do
+      t = f.enum('a', 'b', 'c', true)
+      expect(s.string(t)).to eq("Enum['a', 'b', 'c', true]")
+    end
+
     it "should yield 'Pattern[/pat/,...]' for a PPatternType['pat',...]" do
       t = f.pattern('a')
       t2 = f.pattern('a', 'b', 'c')
@@ -331,7 +349,7 @@ FORMATTED
     end
 
     it "should yield 'Callable[t,min,max]' for callable with size constraint (infinite max)" do
-      expect(s.string(f.callable(String, 0))).to eql('Callable[String, 0, default]')
+      expect(s.string(f.callable(String, 0))).to eql('Callable[String, 0]')
     end
 
     it "should yield 'Callable[t,min,max]' for callable with size constraint (capped max)" do
@@ -341,7 +359,7 @@ FORMATTED
     it "should yield 'Callable[min,max]' callable with size > 0" do
       expect(s.string(f.callable(0, 0))).to eql('Callable[0, 0]')
       expect(s.string(f.callable(0, 1))).to eql('Callable[0, 1]')
-      expect(s.string(f.callable(0, :default))).to eql('Callable[0, default]')
+      expect(s.string(f.callable(0, :default))).to eql('Callable[0]')
     end
 
     it "should yield 'Callable[Callable]' for callable with block" do

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

@@ -36,7 +36,7 @@ describe TypeParser do
   end
 
   [
-    'Any', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric', 'Default'
+    'Any', 'Data', 'CatalogEntry', 'Scalar', 'Undef', 'Numeric', 'Default'
   ].each do |name|
     it "does not support parameterizing unparameterized type <#{name}>" do
       expect { parser.parse("#{name}[Integer]") }.to raise_unparameterized_error_for(name)
@@ -79,6 +79,18 @@ describe TypeParser do
     expect(parser.parse("Hash[Scalar, Integer]")).to be_the_type(types.hash_of(types.integer))
   end
 
+  it 'interprets an Boolean with a true parameter to represent boolean true' do
+    expect(parser.parse('Boolean[true]')).to be_the_type(types.boolean(true))
+  end
+
+  it 'interprets an Boolean with a false parameter to represent boolean false' do
+    expect(parser.parse('Boolean[false]')).to be_the_type(types.boolean(false))
+  end
+
+  it 'does not accept non-boolean parameters' do
+    expect{parser.parse('Boolean["false"]')}.to raise_error(/Boolean parameter must be true or false/)
+  end
+
   it 'interprets an Integer with one parameter to have unbounded upper range' do
     expect(parser.parse('Integer[0]')).to eq(parser.parse('Integer[0,default]'))
   end

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

@@ -153,6 +153,40 @@ describe 'Puppet Type System' do
     end
   end
 
+  context 'Boolean type' do
+    it 'parameterized type is assignable to base type' do
+      code = <<-CODE
+        notice(Boolean[true] < Boolean)
+        notice(Boolean[false] < Boolean)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
+
+    it 'boolean literals are instances of the base type' do
+      code = <<-CODE
+        notice(true =~ Boolean)
+        notice(false =~ Boolean)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
+
+    it 'boolean literals are instances of type parameterized with the same literal' do
+      code = <<-CODE
+        notice(true =~ Boolean[true])
+        notice(false =~ Boolean[false])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
+
+    it 'boolean literals are not instances of type parameterized with a different literal' do
+      code = <<-CODE
+        notice(true =~ Boolean[false])
+        notice(false =~ Boolean[true])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false', 'false'])
+    end
+  end
+
   context 'Enum type' do
     it 'sorts its entries' do
       code = <<-CODE
@@ -167,6 +201,22 @@ describe 'Puppet Type System' do
       CODE
       expect(eval_and_collect_notices(code)).to eq(['a', 'b', 'c'])
     end
+
+    it 'is case sensitive by default' do
+      code = <<-CODE
+        notice('A' =~ Enum[a,b])
+        notice('a' =~ Enum[a,b])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false', 'true'])
+    end
+
+    it 'is case insensitive when last parameter argument is true' do
+      code = <<-CODE
+        notice('A' =~ Enum[a,b,true])
+        notice('a' =~ Enum[a,b,true])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
   end
 
   context 'Iterable type' do
@@ -291,6 +341,8 @@ describe 'Puppet Type System' do
     let!(:mix_ints) { tf.variant(overlapping_ints, adjacent_ints) }
     let!(:overlapping_floats) { tf.variant(tf.float_range(10.0, 20.0), tf.float_range(18.0, 28.0)) }
     let!(:enums) { tf.variant(tf.enum('a', 'b'), tf.enum('b', 'c')) }
+    let!(:enums_s_is) { tf.variant(tf.enum('a', 'b'), tf.enum('b', 'c', true)) }
+    let!(:enums_is_is) { tf.variant(tf.enum('A', 'b', true), tf.enum('B', 'c', true)) }
     let!(:patterns) { tf.variant(tf.pattern('a', 'b'), tf.pattern('b', 'c')) }
     let!(:with_undef) { tf.variant(tf.undef, tf.range(1,10)) }
     let!(:all_optional) { tf.variant(tf.optional(tf.range(1,10)), tf.optional(tf.range(11,20))) }
@@ -317,6 +369,14 @@ describe 'Puppet Type System' do
         expect(enums.normalize).to eq(tf.enum('a', 'b', 'c'))
       end
 
+      it 'are case sensitive versus case insensitive enums, does not merge the enums' do
+        expect(enums_s_is.normalize).to eq(enums_s_is)
+      end
+
+      it 'are case insensitive enums, result is case insensitive and unique irrespective of case' do
+        expect(enums_is_is.normalize).to eq(tf.enum('a', 'b', 'c', true))
+      end
+
       it 'are patterns, the result is a pattern' do
         expect(patterns.normalize).to eq(tf.pattern('a', 'b', 'c'))
       end

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

@@ -153,6 +153,82 @@ describe "validating 4x" do
     end
   end
 
+  context 'with --tasks set' do
+    before(:each) { Puppet[:tasks] = true }
+
+    it 'produces an error for application' do
+      acceptor = validate(parse('application test {}'))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for capability mapping' do
+      acceptor = validate(parse('Foo produces Sql {}'))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for collect expressions with virtual query' do
+      acceptor = validate(parse("User <| title == 'admin' |>"))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for collect expressions with exported query' do
+      acceptor = validate(parse("User <<| title == 'admin' |>>"))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for class expressions' do
+      acceptor = validate(parse('class test {}'))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for node expressions' do
+      acceptor = validate(parse('node default {}'))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for relationship expressions' do
+      acceptor = validate(parse('$x -> $y'))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for resource expressions' do
+      acceptor = validate(parse('notify { nope: }'))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for resource default expressions' do
+      acceptor = validate(parse("File { mode => '0644' }"))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for resource override expressions' do
+      acceptor = validate(parse("File['/tmp/foo'] { mode => '0644' }"))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for resource definitions' do
+      acceptor = validate(parse('define foo($a) {}'))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    it 'produces an error for site definitions' do
+      acceptor = validate(parse('site {}'))
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+  end
+
   context 'for non productive expressions' do
     [ '1',
       '3.14',

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

@@ -7,6 +7,8 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
     described_class.stubs(:command).with(:delete).returns '/usr/sbin/groupdel'
     described_class.stubs(:command).with(:modify).returns '/usr/sbin/groupmod'
     described_class.stubs(:command).with(:localadd).returns '/usr/sbin/lgroupadd'
+    described_class.stubs(:command).with(:localdelete).returns '/usr/sbin/lgroupdel'
+    described_class.stubs(:command).with(:localmodify).returns '/usr/sbin/lgroupmod'
   end
 
   let(:resource) { Puppet::Type.type(:group).new(:name => 'mygroup', :provider => provider) }
@@ -65,12 +67,86 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
 
   end
 
+  describe "#modify" do
+    before do
+       provider.stubs(:exists?).returns(true)
+    end
+    describe "on systems with the libuser and forcelocal=false" do
+      before do
+        described_class.has_feature(:libuser)
+        resource[:forcelocal] = :false
+      end
+
+      it "should use groupmod" do
+        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, 'mygroup'], has_entry(:custom_environment, {}))
+        provider.gid = 150
+      end
+
+      it "should pass -o to groupmod" do
+        resource[:allowdupe] = :true
+        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entry(:custom_environment, {}))
+        provider.gid = 150
+      end
+    end
+    describe "on systems with the libuser and forcelocal=true" do
+      before do
+        described_class.has_feature(:libuser)
+        resource[:forcelocal] = :true
+      end
+
+      it "should use lgroupmod instead of groupmod" do
+        provider.expects(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        provider.gid = 150
+      end
+
+      it "should NOT pass -o to lgroupmod" do
+        resource[:allowdupe] = :true
+        provider.expects(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], has_entry(:custom_environment, has_key('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
+        provider.stubs(:findgroup).returns(true)
+        expect { provider.gid = 150 }.to raise_error(Puppet::Error, "GID 150 already exists, use allowdupe to force group creation")
+     end
+    end
+  end
+
   describe "#gid=" do
     it "should add -o when allowdupe is enabled and the gid is being modified" do
       resource[:allowdupe] = :true
-      provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'])
+      provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entry(:custom_environment, {}))
       provider.gid = 150
     end
   end
+
+  describe "#delete" do
+    before do
+       provider.stubs(:exists?).returns(true)
+    end
+    describe "on systems with the libuser and forcelocal=false" do
+      before do
+        described_class.has_feature(:libuser)
+        resource[:forcelocal] = :false
+      end
+
+      it "should use groupdel" do
+        provider.expects(:execute).with(['/usr/sbin/groupdel', 'mygroup'], has_entry(:custom_environment, {}))
+        provider.delete
+      end
+    end
+    describe "on systems with the libuser and forcelocal=true" do
+      before do
+        described_class.has_feature(:libuser)
+        resource[:forcelocal] = :true
+      end
+
+      it "should use lgroupdel instead of groupdel" do
+        provider.expects(:execute).with(['/usr/sbin/lgroupdel', 'mygroup'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        provider.delete
+      end
+    end
+  end
 end