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

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

@@ -40,36 +40,23 @@ 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_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)
+      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)
     end
 
     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'),
-        ]
-        expect(provider.members_insync?(current, ['user1', 'user2'])).to be_truthy
+        expect(provider.members_insync?(['user1', 'user2'], ['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'),
-        ]
-        expect(provider.members_insync?(current, ['user2', 'user1'])).to be_truthy
+        expect(provider.members_insync?(['user1', 'user2'], ['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'),
-        ]
-        expect(provider.members_insync?(current, ['user2', 'user1', 'user1'])).to be_truthy
+        expect(provider.members_insync?(['user1', 'user2', 'user2'], ['user2', 'user1', 'user1'])).to be_truthy
       end
 
       it "should return true when current and should members are empty lists" do
@@ -90,12 +77,7 @@ 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
-          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
+          expect(provider.members_insync?(['user1', 'user2', 'user3'], ['user3', 'user1', 'user2'])).to be_truthy
         end
 
         it "should return false when current is nil" do
@@ -103,24 +85,15 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return false when should is nil" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-          ]
-          expect(provider.members_insync?(current, nil)).to be_falsey
+          expect(provider.members_insync?(['user1'], 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'),
-          ]
-          expect(provider.members_insync?(current, ['user2'])).to be_falsey
+          expect(provider.members_insync?(['user1'], ['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'),
-          ]
-          expect(provider.members_insync?(current, [])).to be_falsey
+          expect(provider.members_insync?(['user1'], [])).to be_falsey
         end
 
         it "should return false when current is empty and should contains members" do
@@ -128,19 +101,11 @@ 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
-          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
+          expect(provider.members_insync?(['user1', 'user2'], ['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'),
-          ]
-          expect(provider.members_insync?(current, [])).to be_falsey
+          expect(provider.members_insync?(['user1','user2'], [])).to be_falsey
         end
       end
 
@@ -155,24 +120,15 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return true when should is nil" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-          ]
-          expect(provider.members_insync?(current, nil)).to be_truthy
+          expect(provider.members_insync?(['user1'], 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'),
-          ]
-          expect(provider.members_insync?(current, ['user2'])).to be_falsey
+          expect(provider.members_insync?(['user1'], ['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'),
-          ]
-          expect(provider.members_insync?(current, [])).to be_truthy
+          expect(provider.members_insync?(['user1'], [])).to be_truthy
         end
 
         it "should return false when current is empty and should contains members" do
@@ -180,28 +136,15 @@ 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
-          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
+          expect(provider.members_insync?(['user1','user2'], ['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'),
-          ]
-          expect(provider.members_insync?(current, [])).to be_truthy
+          expect(provider.members_insync?(['user1','user2'], [])).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'),
-          ]
-          expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
+          expect(provider.members_insync?(['user3','user1','user2'], ['user2','user1'])).to be_truthy
         end
       end
     end
@@ -253,8 +196,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_principal).with('user2').returns(member_sids[1])
-      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user3').returns(member_sids[2])
+      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])
 
       provider.group.expects(:remove_member_sids).with(member_sids[0])
       provider.group.expects(:add_member_sids).with(member_sids[2])
@@ -304,7 +247,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_principal).returns(nil)
+    Puppet::Util::Windows::SID.stubs(:name_to_sid_object).returns(nil)
     Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'Group')
     expect(provider).to be_exists
 

data/spec/unit/provider/mount_spec.rb

@@ -72,11 +72,24 @@ describe Puppet::Provider::Mount do
 
   describe Puppet::Provider::Mount, " when remounting" do
 
-    it "should use '-o remount' if the resource specifies it supports remounting" do
-      @mounter.stubs(:info)
-      @resource.stubs(:[]).with(:remounts).returns(:true)
-      @mounter.expects(:mountcmd).with("-o", "remount", @name)
-      @mounter.remount
+    context "if the resource supports remounting" do
+      context "given explicit options on AIX" do
+        it "should combine the options with 'remount'" do
+          @mounter.stubs(:info)
+          @mounter.stubs(:options).returns('ro')
+          @resource.stubs(:[]).with(:remounts).returns(:true)
+          Facter.expects(:value).with(:operatingsystem).returns 'AIX'
+          @mounter.expects(:mountcmd).with("-o", "ro,remount", @name)
+          @mounter.remount
+        end
+      end
+
+      it "should use '-o remount'" do
+        @mounter.stubs(:info)
+        @resource.stubs(:[]).with(:remounts).returns(:true)
+        @mounter.expects(:mountcmd).with("-o", "remount", @name)
+        @mounter.remount
+      end
     end
 
     it "should mount with '-o update' on OpenBSD" do

data/spec/unit/provider/nameservice_spec.rb

@@ -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/dnf_spec.rb

@@ -6,7 +6,7 @@ require 'spec_helper'
 provider_class = Puppet::Type.type(:package).provider(:dnf)
 
 context 'default' do
-  [ 19, 20, 21 ].each do |ver|
+  (19..21).each do |ver|
     it "should not be the default provider on fedora#{ver}" do
       Facter.stubs(:value).with(:osfamily).returns(:redhat)
       Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
@@ -15,7 +15,7 @@ context 'default' do
     end
   end
 
-  [ 22, 23, 24 ].each do |ver|
+  (22..26).each do |ver|
     it "should be the default provider on fedora#{ver}" do
       Facter.stubs(:value).with(:osfamily).returns(:redhat)
       Facter.stubs(:value).with(:operatingsystem).returns(:fedora)

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

@@ -196,7 +196,7 @@ context 'installing myresource' do
     describe "listing gems" do
       describe "searching for a single package" do
         it "searches for an exact match" do
-          provider_class.expects(:execute).with(includes('^bundler$'), {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns(File.read(my_fixture('gem-list-single-package')))
+          provider_class.expects(:execute).with(includes('\Abundler\z'), {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns(File.read(my_fixture('gem-list-single-package')))
           expected = {:name => 'bundler', :ensure => %w[1.6.2], :provider => :gem}
           expect(provider_class.gemlist({:justme => 'bundler'})).to eq(expected)
         end

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

@@ -101,6 +101,9 @@ describe Puppet::Type.type(:package).provider(:pkg) do
     end
 
     context ":latest" do
+      before do
+        described_class.expects(:pkg).with(:refresh)
+      end
       it "should work correctly for ensure latest on solaris 11 (UFOXI) when there are no further packages to install" do
         described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.installed'))
         expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')

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

@@ -7,6 +7,46 @@ describe provider_class do
   include PuppetSpec::Fixtures
   it_behaves_like 'RHEL package provider', provider_class, 'yum'
 
+  describe "when supplied the source param" do
+    let(:name) { 'baz' }
+
+    let(:resource) do
+      Puppet::Type.type(:package).new(
+        :name => name,
+        :provider => 'yum',
+      )
+    end
+
+    let(:provider) do
+      provider = provider_class.new
+      provider.resource = resource
+      provider
+    end
+
+    before { provider_class.stubs(:command).with(:cmd).returns("/usr/bin/yum") }
+
+    context "when installing" do
+      it "should use the supplied source as the explicit path to a package to install" do
+        resource[:ensure] = :present
+        resource[:source] = "/foo/bar/baz-1.1.0.rpm"
+        provider.expects(:execute).with(["/usr/bin/yum", "-d", "0", "-e", "0", "-y", :install, "/foo/bar/baz-1.1.0.rpm"])
+        provider.install
+      end
+    end
+
+    context "when ensuring a specific version" do
+      it "should use the suppplied source as the explicit path to the package to update" do
+        # The first query response informs yum provider that package 1.1.0 is
+        # already installed, and the second that it's been upgraded
+        provider.expects(:query).twice.returns({:ensure => "1.1.0"}, {:ensure => "1.2.0"})
+        resource[:ensure] = "1.2.0"
+        resource[:source] = "http://foo.repo.com/baz-1.2.0.rpm"
+        provider.expects(:execute).with(["/usr/bin/yum", "-d", "0", "-e", "0", "-y", 'update',  "http://foo.repo.com/baz-1.2.0.rpm"])
+        provider.install
+      end
+    end
+  end
+
   describe "parsing the output of check-update" do
     describe "with no multiline entries" do
       let(:check_update) { File.read(my_fixture("yum-check-update-simple.txt")) }

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

@@ -292,7 +292,8 @@ describe Puppet::Type.type(:service).provider(:launchd) do
         provider.expects(:launchd_paths).returns(['/Library/LaunchAgents'])
         provider.expects(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').returns([busted_plist_path])
         plistlib.expects(:read_plist_file).with(busted_plist_path).returns(plist_without_label)
-        Puppet.expects(:warning).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
+        Puppet.expects(:debug).with("Reading launchd plist #{busted_plist_path}")
+        Puppet.expects(:debug).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
         provider.make_label_to_path_map
       end
     end

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

@@ -88,6 +88,11 @@ describe provider_class, :if => Puppet.features.posix? do
       expect(@provider.enabled?).to eq(:true)
     end
 
+    it "should check for B" do
+      provider_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}  B"
+      expect(@provider.enabled?).to eq(:true)
+    end
+
     it "should check for off" do
       provider_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}  off"
       expect(@provider.enabled?).to eq(:false)

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

@@ -126,7 +126,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     expect(described_class).not_to be_default
   end
 
-  [ '15.04', '15.10', '16.04', '16.10', '17.04', '17.10', '18.04' ].each do |ver|
+  [ '15.04', '15.10', '16.04', '16.10' ].each do |ver|
     it "should be the default provider on ubuntu#{ver}" do
       Facter.stubs(:value).with(:osfamily).returns(:debian)
       Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)

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

@@ -59,14 +59,14 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
     it "should add modprpw to modifycmd if Trusted System" do
       resource.stubs(:allowdupe?).returns true
       provider.expects(:exec_getprpw).with('root','-m uid').returns('uid=0')
-      provider.expects(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F', ';', '/usr/lbin/modprpw', '-v', '-l', 'testuser'])
+      provider.expects(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F', ';', '/usr/lbin/modprpw', '-v', '-l', 'testuser'], has_entry(:custom_environment, {}))
       provider.uid = 1000
     end
 
     it "should not add modprpw if not Trusted System" do
       resource.stubs(:allowdupe?).returns true
       provider.expects(:exec_getprpw).with('root','-m uid').returns('System is not trusted')
-      provider.expects(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F'])
+      provider.expects(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F'], has_entry(:custom_environment, {}))
       provider.uid = 1000
     end
   end

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

@@ -33,13 +33,13 @@ describe Puppet::Type.type(:user).provider(:openbsd) do
   describe "#expiry=" do
     it "should pass expiry to usermod as MM/DD/YY" do
       resource[:expiry] = '2014-11-05'
-      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', 'November 05 2014', 'myuser'])
+      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', 'November 05 2014', 'myuser'], has_entry(:custom_environment, {}))
       provider.expiry = '2014-11-05'
     end
 
     it "should use -e with an empty string when the expiry property is removed" do
       resource[:expiry] = :absent
-      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', '', 'myuser'])
+      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', '', 'myuser'], has_entry(:custom_environment, {}))
       provider.expiry = :absent
     end
   end

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

@@ -109,7 +109,7 @@ describe provider_class do
       provider = resource.provider
       provider.expects(:exists?).returns true
       expect(provider.deletecmd).to eq([provider_class.command(:pw), "userdel", "testuser"])
-      provider.expects(:execute).with([provider_class.command(:pw), "userdel", "testuser"])
+      provider.expects(:execute).with([provider_class.command(:pw), "userdel", "testuser"], has_entry(:custom_environment, {}))
       provider.delete
     end
 
@@ -120,7 +120,7 @@ describe provider_class do
       provider = resource.provider
       provider.expects(:exists?).returns true
       resource[:managehome] = false
-      provider.expects(:execute).with(Not(includes("-r")))
+      provider.expects(:execute).with(Not(includes("-r")), has_entry(:custom_environment, {}))
       provider.delete
     end
 
@@ -128,7 +128,7 @@ describe provider_class do
       provider = resource.provider
       provider.expects(:exists?).returns true
       resource[:managehome] = true
-      provider.expects(:execute).with(includes("-r"))
+      provider.expects(:execute).with(includes("-r"), has_entry(:custom_environment, {}))
       provider.delete
     end
   end
@@ -140,56 +140,56 @@ describe provider_class do
 
     it "should run pw with the correct arguments" do
       expect(provider.modifycmd("uid", 12345)).to eq([provider_class.command(:pw), "usermod", "testuser", "-u", 12345])
-      provider.expects(:execute).with([provider_class.command(:pw), "usermod", "testuser", "-u", 12345])
+      provider.expects(:execute).with([provider_class.command(:pw), "usermod", "testuser", "-u", 12345], has_entry(:custom_environment, {}))
       provider.uid = 12345
     end
 
     it "should use -c with the correct argument when the comment property is changed" do
       resource[:comment] = "Testuser Name"
-      provider.expects(:execute).with(all_of(includes("-c"), includes("Testuser New Name")))
+      provider.expects(:execute).with(all_of(includes("-c"), includes("Testuser New Name")), has_entry(:custom_environment, {}))
       provider.comment = "Testuser New Name"
     end
 
     it "should use -e with the correct argument when the expiry property is changed" do
       resource[:expiry] = "2010-02-19"
-      provider.expects(:execute).with(all_of(includes("-e"), includes("19-02-2011")))
+      provider.expects(:execute).with(all_of(includes("-e"), includes("19-02-2011")), has_entry(:custom_environment, {}))
       provider.expiry = "2011-02-19"
     end
 
     it "should use -e with the correct argument when the expiry property is removed" do
       resource[:expiry] = :absent
-      provider.expects(:execute).with(all_of(includes("-e"), includes("00-00-0000")))
+      provider.expects(:execute).with(all_of(includes("-e"), includes("00-00-0000")), has_entry(:custom_environment, {}))
       provider.expiry = :absent
     end
 
     it "should use -g with the correct argument when the gid property is changed" do
       resource[:gid] = 12345
-      provider.expects(:execute).with(all_of(includes("-g"), includes(54321)))
+      provider.expects(:execute).with(all_of(includes("-g"), includes(54321)), has_entry(:custom_environment, {}))
       provider.gid = 54321
     end
 
     it "should use -G with the correct argument when the groups property is changed" do
       resource[:groups] = "group1"
-      provider.expects(:execute).with(all_of(includes("-G"), includes("group2")))
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group2")), has_entry(:custom_environment, {}))
       provider.groups = "group2"
     end
 
     it "should use -G with all the given groups when the groups property is changed with an array" do
       resource[:groups] = ["group1", "group2"]
-      provider.expects(:execute).with(all_of(includes("-G"), includes("group3,group4")))
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group3,group4")), has_entry(:custom_environment, {}))
       provider.groups = "group3,group4"
     end
 
     it "should use -d with the correct argument when the home property is changed" do
       resource[:home] = "/home/testuser"
-      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser")))
+      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser")), has_entry(:custom_environment, {}))
       provider.home = "/newhome/testuser"
     end
 
     it "should use -m and -d with the correct argument when the home property is changed and managehome is enabled" do
       resource[:home] = "/home/testuser"
       resource[:managehome] = true
-      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser"), includes("-m")))
+      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser"), includes("-m")), has_entry(:custom_environment, {}))
       provider.home = "/newhome/testuser"
     end
 
@@ -201,13 +201,13 @@ describe provider_class do
 
     it "should use -s with the correct argument when the shell property is changed" do
       resource[:shell] = "/bin/sh"
-      provider.expects(:execute).with(all_of(includes("-s"), includes("/bin/tcsh")))
+      provider.expects(:execute).with(all_of(includes("-s"), includes("/bin/tcsh")), has_entry(:custom_environment, {}))
       provider.shell = "/bin/tcsh"
     end
 
     it "should use -u with the correct argument when the uid property is changed" do
       resource[:uid] = 12345
-      provider.expects(:execute).with(all_of(includes("-u"), includes(54321)))
+      provider.expects(:execute).with(all_of(includes("-u"), includes(54321)), has_entry(:custom_environment, {}))
       provider.uid = 54321
     end
   end