puppet 5.0.0 → 6.0.0

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

@@ -123,7 +123,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       provider.run(provider.resource[:command])
     end
 
-    describe "posix locale settings" do
+    describe "posix locale settings", :unless => RUBY_PLATFORM == 'java' do
       # a sentinel value that we can use to emulate what locale environment variables might be set to on an international
       # system.
       lang_sentinel_value = "en_US.UTF-8"
@@ -140,14 +140,14 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
         Puppet::Util::POSIX::LOCALE_ENV_VARS.each { |var| orig_env[var] = ENV[var] if ENV[var] }
 
         orig_env.keys.each do |var|
-          output, status = provider.run(command % var)
+          output, _ = provider.run(command % var)
           expect(output.strip).to eq(orig_env[var])
         end
 
         # now, once more... but with our sentinel values
         Puppet::Util.withenv(locale_sentinel_env) do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-            output, status = provider.run(command % var)
+            output, _ = provider.run(command % var)
             expect(output.strip).to eq(locale_sentinel_env[var])
           end
         end
@@ -155,14 +155,14 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
 
       it "should respect locale overrides in user's 'environment' configuration" do
         provider.resource[:environment] = ['LANG=C', 'LC_ALL=C']
-        output, status = provider.run(command % 'LANG')
+        output, _ = provider.run(command % 'LANG')
         expect(output.strip).to eq('C')
-        output, status = provider.run(command % 'LC_ALL')
+        output, _ = provider.run(command % 'LC_ALL')
         expect(output.strip).to eq('C')
       end
     end
 
-    describe "posix user-related environment vars" do
+    describe "posix user-related environment vars", :unless => RUBY_PLATFORM == 'java' do
       # a temporary hash that contains sentinel values for each of the user-related environment variables that we
       # are expected to unset during an "exec"
       user_sentinel_env = {}
@@ -180,7 +180,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
             expect(ENV[var]).to eq(user_sentinel_env[var])
 
             # run an "exec" via the provider and ensure that it unsets the vars
-            output, status = provider.run(command % var)
+            output, _ = provider.run(command % var)
             expect(output.strip).to eq("")
 
             # ensure that after the exec, our temporary env is still intact
@@ -199,7 +199,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
         # loop over the posix user-related environment variables
         Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
           # run an 'exec' to get the value of each variable
-          output, status = provider.run(command % var)
+          output, _ = provider.run(command % var)
           # ensure that it matches our expected sentinel value
           expect(output.strip).to eq(sentinel_value)
         end

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

@@ -1,7 +1,8 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:exec).provider(:shell), :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:exec).provider(:shell),
+         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:resource) { Puppet::Type.type(:exec).new(:title => 'foo', :provider => 'shell') }
   let(:provider) { described_class.new(resource) }
 

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
 
   let(:resource) { Puppet::Type.type(:exec).new(:title => 'C:\foo', :provider => :windows) }
@@ -45,7 +45,7 @@ describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet.features.mic
   end
 
   describe "#checkexe" do
-    describe "when the command is absolute", :if => Puppet.features.microsoft_windows? do
+    describe "when the command is absolute", :if => Puppet::Util::Platform.windows? do
       it "should return if the command exists and is a file" do
         command = tmpfile('command')
         FileUtils.touch(command)

data/spec/unit/provider/file/windows_spec.rb

@@ -1,14 +1,14 @@
 #! /usr/bin/env ruby
 
 require 'spec_helper'
-if Puppet.features.microsoft_windows?
+if Puppet::Util::Platform.windows?
   require 'puppet/util/windows'
   class WindowsSecurity
     extend Puppet::Util::Windows::Security
   end
 end
 
-describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:file).provider(:windows), :if => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
 
   let(:path) { tmpfile('windows_file_spec') }

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

@@ -0,0 +1,76 @@
+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
+      provider_class.stubs(:list_all).with(ia_module_args).returns(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
+    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/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_entries({:failonfail => true, :combine => true, :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_entries({:failonfail => true, :combine => true, :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_entries({:failonfail => true, :combine => true, :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_entries({: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(: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
 

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

@@ -54,7 +54,7 @@ describe provider_class 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"])
+      provider.expects(:execute).with([provider_class.command(:pw), "groupdel", "testgroup"], has_entry(:custom_environment, {}))
       provider.delete
     end
   end
@@ -62,19 +62,19 @@ describe provider_class do
   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])
+      provider.expects(:execute).with([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345], has_entry(:custom_environment, {}))
       provider.gid = 12345
     end
 
     it "should use -M with the correct argument when the members property is changed" do
       resource[:members] = "user1"
-      provider.expects(:execute).with(all_of(includes("-M"), includes("user2")))
+      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")))
+      provider.expects(:execute).with(all_of(includes("-M"), includes("user3,user4")), has_entry(:custom_environment, {}))
       provider.members = ["user3", "user4"]
     end
   end

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util::Platform.windows? do
   let(:resource) do
     Puppet::Type.type(:group).new(
       :title => 'testers',
@@ -40,23 +40,36 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     let(:invalid_user) { SecureRandom.uuid }
 
     before :each do
-      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user1').returns(user1)
-      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user2').returns(user2)
-      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user3').returns(user3)
-      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with(invalid_user).returns(nil)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user1').returns(user1)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user2').returns(user2)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user3').returns(user3)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with(invalid_user).returns(nil)
     end
 
     describe "#members_insync?" do
       it "should return true for same lists of members" do
-        expect(provider.members_insync?(['user1', 'user2'], ['user1', 'user2'])).to be_truthy
+        current = [
+          Puppet::Util::Windows::SID.name_to_principal('user1'),
+          Puppet::Util::Windows::SID.name_to_principal('user2'),
+        ]
+        expect(provider.members_insync?(current, ['user1', 'user2'])).to be_truthy
       end
 
       it "should return true for same lists of unordered members" do
-        expect(provider.members_insync?(['user1', 'user2'], ['user2', 'user1'])).to be_truthy
+        current = [
+          Puppet::Util::Windows::SID.name_to_principal('user1'),
+          Puppet::Util::Windows::SID.name_to_principal('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
-        expect(provider.members_insync?(['user1', 'user2', 'user2'], ['user2', 'user1', 'user1'])).to be_truthy
+        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'),
+        ]
+        expect(provider.members_insync?(current, ['user2', 'user1', 'user1'])).to be_truthy
       end
 
       it "should return true when current and should members are empty lists" do
@@ -77,7 +90,12 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return true when current and should contain the same users in a different order" do
-          expect(provider.members_insync?(['user1', 'user2', 'user3'], ['user3', 'user1', 'user2'])).to be_truthy
+          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'),
+          ]
+          expect(provider.members_insync?(current, ['user3', 'user1', 'user2'])).to be_truthy
         end
 
         it "should return false when current is nil" do
@@ -85,15 +103,24 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return false when should is nil" do
-          expect(provider.members_insync?(['user1'], nil)).to be_falsey
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+          ]
+          expect(provider.members_insync?(current, nil)).to be_falsey
         end
 
         it "should return false when current contains different users than should" do
-          expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+          ]
+          expect(provider.members_insync?(current, ['user2'])).to be_falsey
         end
 
         it "should return false when current contains members and should is empty" do
-          expect(provider.members_insync?(['user1'], [])).to be_falsey
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+          ]
+          expect(provider.members_insync?(current, [])).to be_falsey
         end
 
         it "should return false when current is empty and should contains members" do
@@ -101,11 +128,19 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return false when should user(s) are not the only items in the current" do
-          expect(provider.members_insync?(['user1', 'user2'], ['user1'])).to be_falsey
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('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
-          expect(provider.members_insync?(['user1','user2'], [])).to be_falsey
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('user2'),
+          ]
+          expect(provider.members_insync?(current, [])).to be_falsey
         end
       end
 
@@ -120,15 +155,24 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return true when should is nil" do
-          expect(provider.members_insync?(['user1'], nil)).to be_truthy
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+          ]
+          expect(provider.members_insync?(current, nil)).to be_truthy
         end
 
         it "should return false when current contains different users than should" do
-          expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+          ]
+          expect(provider.members_insync?(current, ['user2'])).to be_falsey
         end
 
         it "should return true when current contains members and should is empty" do
-          expect(provider.members_insync?(['user1'], [])).to be_truthy
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+          ]
+          expect(provider.members_insync?(current, [])).to be_truthy
         end
 
         it "should return false when current is empty and should contains members" do
@@ -136,15 +180,28 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return true when current user(s) contains at least the should list" do
-          expect(provider.members_insync?(['user1','user2'], ['user1'])).to be_truthy
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('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
-          expect(provider.members_insync?(['user1','user2'], [])).to be_truthy
+          current = [
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('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
-          expect(provider.members_insync?(['user3','user1','user2'], ['user2','user1'])).to be_truthy
+          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'),
+          ]
+          expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
         end
       end
     end
@@ -196,8 +253,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
       provider.group.stubs(:member_sids).returns(member_sids[0..1])
 
-      Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(member_sids[1])
-      Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user3').returns(member_sids[2])
+      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user2').returns(member_sids[1])
+      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user3').returns(member_sids[2])
 
       provider.group.expects(:remove_member_sids).with(member_sids[0])
       provider.group.expects(:add_member_sids).with(member_sids[2])
@@ -247,7 +304,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   end
 
   it "should be able to test whether a group exists" do
-    Puppet::Util::Windows::SID.stubs(:name_to_sid_object).returns(nil)
+    Puppet::Util::Windows::SID.stubs(:name_to_principal).returns(nil)
     Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'Group')
     expect(provider).to be_exists
 

data/spec/unit/provider/ldap_spec.rb

@@ -72,7 +72,6 @@ describe Puppet::Provider::Ldap do
 
     describe "resources that do not exist" do
       it "should create a provider with :ensure => :absent" do
-        result = mock 'result'
         @manager.expects(:find).with("one").returns nil
 
         @class.expects(:new).with(:ensure => :absent).returns "myprovider"

data/spec/unit/provider/nameservice_spec.rb

@@ -160,7 +160,7 @@ describe Puppet::Provider::NameService do
     it "should return a list of users if resource_type is user" do
       described_class.resource_type = Puppet::Type.type(:user)
       Puppet::Etc.expects(:setpwent)
-      Puppet::Etc.stubs(:getpwent).returns *users
+      Puppet::Etc.stubs(:getpwent).returns(*users)
       Puppet::Etc.expects(:endpwent)
       expect(described_class.listbyname).to eq(%w{root foo})
     end
@@ -172,7 +172,7 @@ describe Puppet::Provider::NameService do
       # the same name on disk, but each name is stored on disk in a different
       # encoding
       it "should return names with invalid byte sequences replaced with '?'" do
-        Etc.stubs(:getpwent).returns *utf_8_mixed_users
+        Etc.stubs(:getpwent).returns(*utf_8_mixed_users)
         expect(invalid_utf_8_jose).to_not be_valid_encoding
         result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
           described_class.listbyname
@@ -181,7 +181,7 @@ describe Puppet::Provider::NameService do
       end
 
       it "should return names in their original encoding/bytes if they would not be valid UTF-8" do
-        Etc.stubs(:getpwent).returns *latin_1_mixed_users
+        Etc.stubs(:getpwent).returns(*latin_1_mixed_users)
         result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
           described_class.listbyname
         end
@@ -189,10 +189,10 @@ describe Puppet::Provider::NameService do
       end
     end
 
-    it "should return a list of groups if resource_type is group", :unless => Puppet.features.microsoft_windows? do
+    it "should return a list of groups if resource_type is group", :unless => Puppet::Util::Platform.windows? do
       described_class.resource_type = Puppet::Type.type(:group)
       Puppet::Etc.expects(:setgrent)
-      Puppet::Etc.stubs(:getgrent).returns *groups
+      Puppet::Etc.stubs(:getgrent).returns(*groups)
       Puppet::Etc.expects(:endgrent)
       expect(described_class.listbyname).to eq(%w{root bin})
     end
@@ -201,7 +201,7 @@ describe Puppet::Provider::NameService do
       yield_results = []
       described_class.resource_type = Puppet::Type.type(:user)
       Puppet::Etc.expects(:setpwent)
-      Puppet::Etc.stubs(:getpwent).returns *users
+      Puppet::Etc.stubs(:getpwent).returns(*users)
       Puppet::Etc.expects(:endpwent)
       described_class.listbyname {|x| yield_results << x }
       expect(yield_results).to eq(%w{root foo})
@@ -393,20 +393,20 @@ describe Puppet::Provider::NameService do
 
     it "should execute the modify command on valid values" do
       provider.expects(:modifycmd).with(:foo, 100).returns ['/bin/modify', '-f', '100' ]
-      provider.expects(:execute).with ['/bin/modify', '-f', '100']
+      provider.expects(:execute).with(['/bin/modify', '-f', '100'], has_entry(:custom_environment, {}))
       provider.set(:foo, 100)
     end
 
     it "should munge the value first" do
       described_class.options(:foo, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
-      provider.expects(:modifycmd).with(:foo, 200).returns ['/bin/modify', '-f', '200' ]
-      provider.expects(:execute).with ['/bin/modify', '-f', '200']
+      provider.expects(:modifycmd).with(:foo, 200).returns(['/bin/modify', '-f', '200' ])
+      provider.expects(:execute).with(['/bin/modify', '-f', '200'], has_entry(:custom_environment, {}))
       provider.set(:foo, 100)
     end
 
     it "should fail if the modify command fails" do
-      provider.expects(:modifycmd).with(:foo, 100).returns ['/bin/modify', '-f', '100' ]
-      provider.expects(:execute).with(['/bin/modify', '-f', '100']).raises(Puppet::ExecutionFailure, "Execution of '/bin/modify' returned 1: some_failure")
+      provider.expects(:modifycmd).with(:foo, 100).returns(['/bin/modify', '-f', '100' ])
+      provider.expects(:execute).with(['/bin/modify', '-f', '100'], kind_of(Hash)).raises(Puppet::ExecutionFailure, "Execution of '/bin/modify' returned 1: some_failure")
       expect { provider.set(:foo, 100) }.to raise_error Puppet::Error, /Could not set foo/
     end
   end

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

@@ -25,7 +25,6 @@ describe provider_class do
 
   describe "when installing" do
     it "should install a package" do
-      @resource.stubs(:should).with(:ensure).returns(:installed)
       @provider.expects(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
       @provider.install
     end
@@ -98,10 +97,36 @@ mypackage                 1.2.3.3         Already superseded by 1.2.3.4
       @provider.stubs(:latest_info).returns( { :version => "1.2.3.5" } )
       expect(@provider.latest).to eq("1.2.3.5")
     end
+
+    it "should prefetch the right values" do
+      Process.stubs(:euid).returns(0)
+      resource = Puppet::Type.type(:package).
+          new(:name => 'sudo.rte', :ensure => :latest,
+              :source => 'mysource', :provider => :aix)
+
+      resource.stubs(:should).with(:ensure).returns(:latest)
+      resource.should(:ensure)
+
+      resource.provider.class.stubs(:execute).returns(<<-END.chomp)
+sudo:sudo.rte:1.7.10.4::I:C:::::N:Configurable super-user privileges runtime::::0::
+sudo:sudo.rte:1.8.6.4::I:T:::::N:Configurable super-user privileges runtime::::0::
+END
+
+      resource.provider.class.prefetch('sudo.rte' => resource)
+      expect(resource.provider.latest).to eq('1.8.6.4')
+    end
   end
 
   it "update should install a package" do
     @provider.expects(:install).with(false)
     @provider.update
   end
+
+  it "should prefetch when some packages lack sources" do
+    latest = Puppet::Type.type(:package).new(:name => 'mypackage', :ensure => :latest, :source => 'mysource', :provider => :aix)
+    absent = Puppet::Type.type(:package).new(:name => 'otherpackage', :ensure => :absent, :provider => :aix)
+    Process.stubs(:euid).returns(0)
+    provider_class.expects(:execute).returns 'mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n'
+    provider_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
+  end
 end

data/spec/unit/provider/package/aptitude_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
         Puppet::Util::Execution.expects(:execute).with(
           [dpkgquery_path, '-W', '--showformat', "'${Status} ${Package} ${Version}\\n'", 'faff'],
           {:failonfail => true, :combine => true, :custom_environment => {}}
-        ).returns(output)
+        ).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
 
         expect(pkg.property(:ensure).retrieve).to eq(expect)
       end

data/spec/unit/provider/package/aptrpm_spec.rb

@@ -13,7 +13,7 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
     before(:each) do
       Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
       pkg.provider.stubs(:which).with("rpm").returns("/bin/rpm")
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns("4.10.1\n").at_most_once
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most_once
     end
 
     def rpm_args