puppet 6.0.0-universal-darwin → 6.0.1-universal-darwin

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

@@ -54,23 +54,4 @@ describe 'Puppet::Type::Group::Provider::Aix' 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
-    it 'returns the members property as-is if it is not an Array' do
-      expect(provider_class.members_to_users('members'))
-        .to eql('members')
-    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')
-    end
-  end
 end

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

@@ -71,11 +71,5 @@ describe provider_class do
       provider.expects(:execute).with(all_of(includes("-M"), includes("user2")), has_entry(: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"]
-      provider.expects(:execute).with(all_of(includes("-M"), includes("user3,user4")), has_entry(:custom_environment, {}))
-      provider.members = ["user3", "user4"]
-    end
   end
 end

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

@@ -49,25 +49,25 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
     describe "#members_insync?" do
       it "should return true for same lists of members" do
         current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
+          'user1',
+          'user2'
         ]
         expect(provider.members_insync?(current, ['user1', 'user2'])).to be_truthy
       end
 
       it "should return true for same lists of unordered members" do
         current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
+          'user1',
+          'user2'
         ]
         expect(provider.members_insync?(current, ['user2', 'user1'])).to be_truthy
       end
 
       it "should return true for same lists of members irrespective of duplicates" do
         current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
+          'user1',
+          'user2',
+          'user2'
         ]
         expect(provider.members_insync?(current, ['user2', 'user1', 'user1'])).to be_truthy
       end
@@ -91,9 +91,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
 
         it "should return true when current and should contain the same users in a different order" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
-            Puppet::Util::Windows::SID.name_to_principal('user3'),
+            'user1',
+            'user2',
+            'user3'
           ]
           expect(provider.members_insync?(current, ['user3', 'user1', 'user2'])).to be_truthy
         end
@@ -104,21 +104,21 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
 
         it "should return false when should is nil" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, nil)).to be_falsey
         end
 
         it "should return false when current contains different users than should" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, ['user2'])).to be_falsey
         end
 
         it "should return false when current contains members and should is empty" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, [])).to be_falsey
         end
@@ -129,16 +129,16 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
 
         it "should return false when should user(s) are not the only items in the current" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, ['user1'])).to be_falsey
         end
 
         it "should return false when current user(s) is not empty and should is an empty list" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, [])).to be_falsey
         end
@@ -156,21 +156,21 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
 
         it "should return true when should is nil" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, nil)).to be_truthy
         end
 
         it "should return false when current contains different users than should" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, ['user2'])).to be_falsey
         end
 
         it "should return true when current contains members and should is empty" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, [])).to be_truthy
         end
@@ -181,25 +181,25 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
 
         it "should return true when current user(s) contains at least the should list" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, ['user1'])).to be_truthy
         end
 
         it "should return true when current user(s) is not empty and should is an empty list" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, [])).to be_truthy
         end
 
         it "should return true when current user(s) contains at least the should list, even unordered" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user3'),
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user3',
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
         end
@@ -238,13 +238,14 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
 
     it "should be able to provide a list of members" do
       provider.group.stubs(:members).returns ['user1', 'user2', 'user3']
+      Puppet::Util::Windows::ADSI::User.stubs(:name_sid_hash)
+        .with(provider.group.members)
+        .returns({ 'user1' => '', 'user2' => '', 'user3' => '' })
 
       expect(provider.members).to match_array(['user1', 'user2', 'user3'])
     end
 
     it "should be able to set group members" do
-      provider.group.stubs(:members).returns ['user1', 'user2']
-
       member_sids = [
         stub(:account => 'user1', :domain => 'testcomputername', :sid => 1),
         stub(:account => 'user2', :domain => 'testcomputername', :sid => 2),
@@ -259,7 +260,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
       provider.group.expects(:remove_member_sids).with(member_sids[0])
       provider.group.expects(:add_member_sids).with(member_sids[2])
 
-      provider.members = ['user2', 'user3']
+      provider.members = 'user2,user3'
     end
   end
 
@@ -268,12 +269,13 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
       resource[:members] = ['user1', 'user2']
 
       group = stub 'group'
+      group.stubs(:members).returns([])
       Puppet::Util::Windows::ADSI::Group.expects(:create).with('testers').returns group
 
       create = sequence('create')
       group.expects(:commit).in_sequence(create)
       # due to PUP-1967, defaultto false will set the default to nil
-      group.expects(:set_members).with(['user1', 'user2'], nil).in_sequence(create)
+      group.expects(:set_members).with('user1,user2', nil).in_sequence(create)
 
       provider.create
     end
@@ -290,10 +292,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
       connection.expects(:Create)
       connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
 
-      expect{ provider.create }.to raise_error(
-                                       Puppet::Error,
-                                       /not able to create\/delete domain groups/
-                                   )
+      expect{ provider.create }.to raise_error(Puppet::Error)
     end
 
     it 'should commit a newly created group' do

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

@@ -17,13 +17,13 @@ end
 
     it "[#6009] should handle nested arrays of members" do
       current = ["foo", "bar", "baz"]
-      desired = ["foo", ["quux"], "qorp"]
+      desired = "foo,quux,qorp"
       group   = 'example'
 
       @resource.stubs(:[]).with(:name).returns(group)
       @resource.stubs(:[]).with(:auth_membership).returns(true)
       @provider.instance_variable_set(:@property_value_cache_hash,
-                                      { :members => current })
+                                      { :members => current.join(',') })
 
       %w{bar baz}.each do |del|
         @provider.expects(:execute).once.

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

@@ -345,4 +345,23 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
       expect { provider.jobsearch("NOSUCH") }.to raise_error(Puppet::Error)
     end
   end
+
+  describe "read_overrides" do
+    before do
+      Kernel.stubs(:sleep)
+    end
+    it "should read overrides" do
+      provider.expects(:read_plist).once.returns({})
+      expect(provider.read_overrides).to eq({})
+    end
+    it "should retry if read_plist fails" do
+      provider.expects(:read_plist).once.returns({})
+      provider.expects(:read_plist).once.returns(nil)
+      expect(provider.read_overrides).to eq({})
+    end
+    it "raises Puppet::Error after 20 attempts" do
+      provider.expects(:read_plist).times(20).returns(nil)
+      expect { provider.read_overrides }.to raise_error(Puppet::Error)
+    end
+ end
 end

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

@@ -70,11 +70,23 @@ describe 'Puppet::Type::User::Provider::Aix' do
     end
   end
 
-  describe '.groups_to_groups' do
+  describe '.groups_attribute_to_property' do
+    it "reads the user's groups from the etc/groups file" do
+      groups = ['system', 'adm']
+      Puppet::Util::POSIX.stubs(:groups_of).with(resource[:name]).returns(groups)
+
+      actual_groups = provider_class.groups_attribute_to_property(provider, 'unused_value')
+      expected_groups = groups.join(',')
+
+      expect(actual_groups).to eql(expected_groups)
+    end
+  end
+
+  describe '.groups_property_to_attribute' do
     it 'raises an ArgumentError if the groups are space-separated' do
       groups = "foo bar baz"
       expect do
-        provider_class.groups_to_groups(groups)
+        provider_class.groups_property_to_attribute(groups)
       end.to raise_error do |error|
         expect(error).to be_a(ArgumentError)
 
@@ -84,6 +96,33 @@ describe 'Puppet::Type::User::Provider::Aix' do
     end
   end
 
+  describe '#gid=' do
+    let(:value) { 'new_pgrp' }
+
+    let(:old_pgrp) { 'old_pgrp' }
+    let(:cur_groups) { 'system,adm' }
+    before(:each) do
+      provider.stubs(:gid).returns(old_pgrp)
+      provider.stubs(:groups).returns(cur_groups)
+      provider.stubs(:set)
+    end
+
+    it 'raises a Puppet::Error if it fails to set the groups property' do
+      provider.stubs(:set)
+        .with(:groups, cur_groups)
+        .raises(Puppet::ExecutionFailure, 'failed to reset the groups!')
+
+      expect { provider.gid = value }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Error)
+
+        expect(error.message).to match('groups')
+        expect(error.message).to match(cur_groups)
+        expect(error.message).to match(old_pgrp)
+        expect(error.message).to match(value)
+      end
+    end
+  end
+
   describe '#parse_password' do
     def call_parse_password
       File.open(my_fixture('aix_passwd_file.out')) do |f|
@@ -163,9 +202,11 @@ describe 'Puppet::Type::User::Provider::Aix' do
   describe '#create' do
     it 'should create the user' do
       provider.resource.stubs(:should).with(anything).returns(nil)
+      provider.resource.stubs(:should).with(:groups).returns('g1,g2')
       provider.resource.stubs(:should).with(:password).returns('password')
 
       provider.expects(:execute)
+      provider.expects(:groups=).with('g1,g2')
       provider.expects(:password=).with('password')
 
       provider.create

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

@@ -259,10 +259,7 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
       connection.expects(:Put).with('UserFlags', true)
       connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
 
-      expect{ provider.create }.to raise_error(
-        Puppet::Error,
-        /not able to create\/delete domain users/
-      )
+      expect{ provider.create }.to raise_error(Puppet::Error)
     end
   end
 

data/spec/unit/puppet_pal_2pec.rb

@@ -767,13 +767,13 @@ describe 'Puppet Pal' do
               [ signature.runnable_with?('string_param' => 'foo', 'int_param' => 10),
                 signature.runnable_with?('anything_goes' => 'foo'),
                 signature.task_hash['name'],
-                signature.task_hash['parameters']['string_param']['description'],
-                signature.task.description,
-                signature.task.parameters['int_param']['type'],
+                signature.task_hash['metadata']['parameters']['string_param']['description'],
+                signature.task_hash['metadata']['description'],
+                signature.task_hash['metadata']['parameters']['int_param']['type'],
               ]
             end
           end
-          expect(result).to eq([true, false, 'b::atask', 'A string parameter', 'test task b::atask', Puppet::Pops::Types::PIntegerType::DEFAULT])
+          expect(result).to eq([true, false, 'b::atask', 'A string parameter', 'test task b::atask', 'Integer'])
         end
 
         it '"TaskSignature#runnable_with?" calls a given lambda if there is an error' do
@@ -802,7 +802,7 @@ describe 'Puppet Pal' do
               signature.task_hash
             end
           end
-          expect(result['input_method']).to be_nil
+          expect(result['metadata']['input_method']).to be_nil
         end
 
         it 'task input_method is parsed from task metadata' do
@@ -812,7 +812,7 @@ describe 'Puppet Pal' do
               signature.task_hash
             end
           end
-          expect(result['input_method']).to eq('stdin')
+          expect(result['metadata']['input_method']).to eq('stdin')
         end
 
         it '"list_tasks" returns an array with all tasks that can be loaded' do

data/spec/unit/puppet_pal_catalog_spec.rb

@@ -463,6 +463,64 @@ describe 'Puppet Pal' do
         end.to raise_error(/does not represent a literal value/)
       end
 
+      it 'the "evaluate" method evaluates but does not evaluate lazy constructs' do
+        result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+          ctx.with_catalog_compiler do |c|
+            c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: }'))
+            c.with_json_encoding() {|encoder| encoder.encode }
+          end
+        end
+        parsed = JSON.parse(result)
+        expect(parsed['resources']).to_not include(include('type' => 'Notify'))
+      end
+
+      it 'an "evaluate" followed by "compile_additions" evaluates lazy constructs' do
+        result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+          ctx.with_catalog_compiler do |c|
+            c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: }'))
+            c.compile_additions
+            c.with_json_encoding() {|encoder| encoder.encode }
+          end
+        end
+        parsed = JSON.parse(result)
+        expect(parsed['resources']).to include(include('type' => 'Notify'))
+      end
+
+      it 'an "evaluate" followed by "compile_additions" validates the result' do
+        expect do
+          Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+            ctx.with_catalog_compiler do |c|
+              c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: before =>"Bar[nope]"}'))
+              c.compile_additions
+            end
+          end
+        end.to raise_error(Puppet::Error, /Could not find resource 'Bar\[nope\]'/)
+      end
+
+      it 'an "evaluate" followed by "evaluate_additions" does not validate the result' do
+        result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+          ctx.with_catalog_compiler do |c|
+            c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: before =>"Bar[nope]"}'))
+            c.evaluate_additions
+            c.with_json_encoding() {|encoder| encoder.encode }
+          end
+        end
+        parsed = JSON.parse(result)
+        expect(parsed['resources']).to include(include('type' => 'Notify'))
+      end
+
+      it 'an "evaluate" followed by "evaluate_additions" and "validate" validates the result' do
+        expect do
+          Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+            ctx.with_catalog_compiler do |c|
+              c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: before =>"Bar[nope]"}'))
+              c.compile_additions
+              c.validate
+            end
+          end
+        end.to raise_error(Puppet::Error, /Could not find resource 'Bar\[nope\]'/)
+      end
+
     end
   end