puppet 5.0.0 → 6.0.0

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

@@ -5,63 +5,44 @@
 
 require 'spec_helper'
 
-require 'win32/service' if Puppet.features.microsoft_windows?
+require 'win32/service' if Puppet::Util::Platform.windows?
 
-describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.microsoft_windows? do
+describe 'Puppet::Type::Service::Provider::Windows',
+    :if => Puppet::Util::Platform.windows? && !Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:windows) }
   let(:name)     { 'nonexistentservice' }
   let(:resource) { Puppet::Type.type(:service).new(:name => name, :provider => :windows) }
   let(:provider) { resource.provider }
   let(:config)   { Struct::ServiceConfigInfo.new }
   let(:status)   { Struct::ServiceStatus.new }
+  let(:service_util) { Puppet::Util::Windows::Service }
+  let(:service_handle) { mock() }
 
   before :each do
     # make sure we never actually execute anything (there are two execute methods)
     provider.class.expects(:execute).never
     provider.expects(:execute).never
-
-    Win32::Service.stubs(:config_info).with(name).returns(config)
-    Win32::Service.stubs(:status).with(name).returns(status)
   end
 
   describe ".instances" do
     it "should enumerate all services" do
-      list_of_services = ['snmptrap', 'svchost', 'sshd'].map { |s| stub('service', :service_name => s) }
-      Win32::Service.expects(:services).returns(list_of_services)
+      list_of_services = {'snmptrap' => {}, 'svchost' => {}, 'sshd' => {}}
+      service_util.expects(:services).returns(list_of_services)
 
-      expect(described_class.instances.map(&:name)).to match_array(['snmptrap', 'svchost', 'sshd'])
+      expect(provider_class.instances.map(&:name)).to match_array(['snmptrap', 'svchost', 'sshd'])
     end
   end
 
   describe "#start" do
-    before :each do
-      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START)
-    end
-
     it "should start the service" do
-      provider.expects(:net).with(:start, name)
-
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_AUTO_START)
+      service_util.expects(:start).with(name)
       provider.start
     end
 
-    it "should raise an error if the start command fails" do
-      provider.expects(:net).with(:start, name).raises(Puppet::ExecutionFailure, "The service name is invalid.")
-
-      expect {
-        provider.start
-      }.to raise_error(Puppet::Error, /Cannot start #{name}, error was: The service name is invalid./)
-    end
-
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:config_info).with(name).raises(SystemCallError, 'OpenService')
-
-      expect {
-        provider.start
-      }.to raise_error(Puppet::Error, /Cannot get start type for #{name}/)
-    end
-
-    describe "when the service is disabled" do
+    context "when the service is disabled" do
       before :each do
-        config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
+        service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
       end
 
       it "should refuse to start if not managing enable" do
@@ -70,18 +51,16 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
       it "should enable if managing enable and enable is true" do
         resource[:enable] = :true
-
-        provider.expects(:net).with(:start, name)
-        Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
+        service_util.expects(:start).with(name)
+        service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
 
         provider.start
       end
 
       it "should manual start if managing enable and enable is false" do
         resource[:enable] = :false
-
-        provider.expects(:net).with(:start, name)
-        Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
+        service_util.expects(:start).with(name)
+        service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
 
         provider.start
       end
@@ -90,44 +69,36 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#stop" do
     it "should stop a running service" do
-      provider.expects(:net).with(:stop, name)
+      service_util.expects(:stop).with(name)
 
       provider.stop
     end
-
-    it "should raise an error if the stop command fails" do
-      provider.expects(:net).with(:stop, name).raises(Puppet::ExecutionFailure, 'The service name is invalid.')
-
-      expect {
-        provider.stop
-      }.to raise_error(Puppet::Error, /Cannot stop #{name}, error was: The service name is invalid./)
-    end
   end
 
   describe "#status" do
-    ['stopped', 'paused', 'stop pending', 'pause pending'].each do |state|
+    [
+      :SERVICE_STOPPED,
+      :SERVICE_PAUSED,
+      :SERVICE_STOP_PENDING,
+      :SERVICE_PAUSE_PENDING,
+    ].each do |state|
       it "should report a #{state} service as stopped" do
-        status.current_state = state
-
+        service_util.expects(:service_state).with(name).returns(state)
         expect(provider.status).to eq(:stopped)
       end
     end
 
-    ["running", "continue pending", "start pending" ].each do |state|
+    [
+      :SERVICE_RUNNING,
+      :SERVICE_CONTINUE_PENDING,
+      :SERVICE_START_PENDING,
+    ].each do |state|
       it "should report a #{state} service as running" do
-        status.current_state = state
+        service_util.expects(:service_state).with(name).returns(state)
 
         expect(provider.status).to eq(:running)
       end
     end
-
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:status).with(name).raises(SystemCallError, 'OpenService')
-
-      expect {
-        provider.status
-      }.to raise_error(Puppet::Error, /Cannot get status of #{name}/)
-    end
   end
 
   describe "#restart" do
@@ -151,33 +122,25 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#enabled?" do
     it "should report a service with a startup type of manual as manual" do
-      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
-
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DEMAND_START)
       expect(provider.enabled?).to eq(:manual)
     end
 
     it "should report a service with a startup type of disabled as false" do
-      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
-
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
       expect(provider.enabled?).to eq(:false)
     end
 
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:config_info).with(name).raises(SystemCallError, 'OpenService')
-
-      expect {
-        provider.enabled?
-      }.to raise_error(Puppet::Error, /Cannot get start type for #{name}/)
-    end
-
     # We need to guard this section explicitly since rspec will always
     # construct all examples, even if it isn't going to run them.
     if Puppet.features.microsoft_windows?
-      [Win32::Service::SERVICE_AUTO_START, Win32::Service::SERVICE_BOOT_START, Win32::Service::SERVICE_SYSTEM_START].each do |start_type_const|
-        start_type = Win32::Service.get_start_type(start_type_const)
+      [
+        :SERVICE_AUTO_START,
+        :SERVICE_BOOT_START,
+        :SERVICE_SYSTEM_START
+      ].each do |start_type|
         it "should report a service with a startup type of '#{start_type}' as true" do
-          config.start_type = start_type
-
+          service_util.expects(:service_start_type).with(name).returns(start_type)
           expect(provider.enabled?).to eq(:true)
         end
       end
@@ -186,12 +149,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#enable" do
     it "should set service start type to Service_Auto_Start when enabled" do
-      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
       provider.enable
     end
 
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+    it "raises an error if set_startup_mode fails" do
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.enable
@@ -201,12 +164,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#disable" do
     it "should set service start type to Service_Disabled when disabled" do
-      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DISABLED).returns(Win32::Service)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED)
       provider.disable
-     end
+    end
 
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+    it "raises an error if set_startup_mode fails" do
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.disable
@@ -216,12 +179,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#manual_start" do
     it "should set service start type to Service_Demand_Start (manual) when manual" do
-      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
       provider.manual_start
     end
 
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+    it "raises an error if set_startup_mode fails" do
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.manual_start

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

@@ -1,169 +1,174 @@
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:user).provider(:aix)
-
-describe provider_class do
-
-  let(:lsuser_all_example) do
-    <<-OUTPUT
-root id=0 pgrp=system groups=system,bin,sys,security,cron,audit,lp home=/root shell=/usr/bin/bash auditclasses=general login=true su=true rlogin=true daemon=true admin=true sugroups=ALL admgroups=lolt,allstaff tpath=nosak ttys=ALL expires=0 auth1=SYSTEM auth2=NONE umask=22 registry=files SYSTEM=compat logintimes= loginretries=0 pwdwarntime=0 account_locked=false minage=0 maxage=0 maxexpired=-1 minalpha=0 minother=0 mindiff=0 maxrepeats=8 minlen=0 histexpire=0 histsize=0 pwdchecks= dictionlist= default_roles= fsize=2097151 cpu=-1 data=262144 stack=65536 core=2097151 rss=65536 nofiles=2000 time_last_login=1358465855 time_last_unsuccessful_login=1358378454 tty_last_login=ssh tty_last_unsuccessful_login=ssh host_last_login=rpm-builder.puppetlabs.lan host_last_unsuccessful_login=192.168.100.78 unsuccessful_login_count=0 roles=
-guest id=100 pgrp=usr groups=usr home=/home/guest login=true su=true rlogin=true daemon=true admin=false sugroups=ALL admgroups= tpath=nosak ttys=ALL expires=0 auth1=SYSTEM auth2=NONE umask=22 registry=files SYSTEM=compat logintimes= loginretries=0 pwdwarntime=0 account_locked=false minage=0 maxage=0 maxexpired=-1 minalpha=0 minother=0 mindiff=0 maxrepeats=8 minlen=0 histexpire=0 histsize=0 pwdchecks= dictionlist= default_roles= fsize=2097151 cpu=-1 data=262144 stack=65536 core=2097151 rss=65536 nofiles=2000 roles=
-    OUTPUT
+describe 'Puppet::Type::User::Provider::Aix' do
+  let(:provider_class) { Puppet::Type.type(:user).provider(:aix) }
+  let(:group_provider_class) { Puppet::Type.type(:group).provider(:aix) }
+
+  let(:resource) do
+    Puppet::Type.type(:user).new(
+      :name   => 'test_aix_user',
+      :ensure => :present
+    )
   end
-
-  let(:lsgroup_all_example) do
-    <<-OUTPUT
-root id=0 pgrp=system groups=system,bin,sys,security,cron,audit,lp home=/root shell=/usr/bin/bash
-guest id=100 pgrp=usr groups=usr home=/home/guest
-    OUTPUT
-  end
-
-  before do
-    @resource = stub('resource')
-    @provider = provider_class.new(@resource)
+  let(:provider) do
+    provider_class.new(resource)
   end
 
-  it "should be able to return a group name based on a group ID" do
-    @provider.stubs(:lsgroupscmd)
+  describe '.pgrp_to_gid' do
+    it "finds the primary group's gid" do
+      provider.stubs(:ia_module_args).returns(['-R', 'module'])
 
-    @provider.stubs(:execute).returns(lsgroup_all_example)
+      group_provider_class.expects(:list_all)
+        .with(provider.ia_module_args)
+        .returns([{ :name => 'group', :id => 1}])
 
-    expect(@provider.groupname_by_id(100)).to eq('guest')
+      expect(provider_class.pgrp_to_gid(provider, 'group')).to eql(1)
+    end
   end
 
-  it "should be able to list all users" do
-    provider_class.stubs(:command)
+  describe '.gid_to_pgrp' do
+    it "finds the gid's primary group" do
+      provider.stubs(:ia_module_args).returns(['-R', 'module'])
 
-    provider_class.stubs(:execute).returns(lsuser_all_example)
+      group_provider_class.expects(:list_all)
+        .with(provider.ia_module_args)
+        .returns([{ :name => 'group', :id => 1}])
 
-    expect(provider_class.list_all).to eq(['root', 'guest'])
+      expect(provider_class.gid_to_pgrp(provider, 1)).to eql('group')
+    end
   end
 
-  describe "#managed_attribute_keys" do
-    let(:existing_attributes) do
-      { :account_locked => 'false',
-        :admin => 'false',
-        :login => 'true',
-        'su' => 'true'
-      }
+  describe '.expires_to_expiry' do
+    it 'returns absent if expires is 0' do
+      expect(provider_class.expires_to_expiry(provider, '0')).to eql(:absent)
     end
 
-    before(:each) do
-      original_parameters = { :attributes => attribute_array }
-      @resource.stubs(:original_parameters).returns(original_parameters)
+    it 'returns absent if the expiry attribute is not formatted properly' do
+      expect(provider_class.expires_to_expiry(provider, 'bad_format')).to eql(:absent)
     end
 
-    describe "invoked via manifest" do
-      let(:attribute_array) { ["rlogin=false", "login =true"] }
-      let(:single_attribute_array) { "rlogin=false" }
-
-      it "should return only the keys of the attribute key=value pair from manifest" do
-        keys = @provider.managed_attribute_keys(existing_attributes)
-        expect(keys).to be_include(:rlogin)
-        expect(keys).to be_include(:login)
-        expect(keys).not_to be_include(:su)
-      end
-
-      it "should strip spaces from symbols" do
-        keys = @provider.managed_attribute_keys(existing_attributes)
-        expect(keys).to be_include(:login)
-        expect(keys).not_to be_include(:"login ")
-      end
+    it 'returns the password expiration date' do
+      expect(provider_class.expires_to_expiry(provider, '0910122314')).to eql('2014-09-10')
+    end
+  end
 
-      it "should have the same count as that from the manifest" do
-        keys = @provider.managed_attribute_keys(existing_attributes)
-        expect(keys.size).to eq(attribute_array.size)
-      end
+  describe '.expiry_to_expires' do
+    it 'returns 0 if the expiry date is 0000-00-00' do
+      expect(provider_class.expiry_to_expires('0000-00-00')).to eql('0')
+    end
 
-      it "should convert the keys to symbols" do
-        keys = @provider.managed_attribute_keys(existing_attributes)
-        all_symbols = keys.all? {|k| k.is_a? Symbol}
-        expect(all_symbols).to be_truthy
-      end
+    it 'returns 0 if the expiry date is "absent"' do
+      expect(provider_class.expiry_to_expires('absent')).to eql('0')
+    end
 
-      it "should allow a single attribute to be specified" do
-        @resource.stubs(:original_parameters).returns({ :attributes => single_attribute_array })
-        keys = @provider.managed_attribute_keys(existing_attributes)
-        expect(keys).to be_include(:rlogin)
-      end
+    it 'returns 0 if the expiry date is :absent' do
+      expect(provider_class.expiry_to_expires(:absent)).to eql('0')
     end
 
-    describe "invoked via RAL" do
-      let(:attribute_array) { nil }
+    it 'returns the expires attribute value' do
+      expect(provider_class.expiry_to_expires('2014-09-10')).to eql('0910000014')
+    end
+  end
 
-      it "should return the keys in supplied hash" do
-        keys = @provider.managed_attribute_keys(existing_attributes)
-        expect(keys).not_to be_include(:rlogin)
-        expect(keys).to be_include(:login)
-        expect(keys).to be_include(:su)
-      end
+  describe '.groups_to_groups' do
+    it 'raises an ArgumentError if the groups are space-separated' do
+      groups = "foo bar baz"
+      expect do
+        provider_class.groups_to_groups(groups)
+      end.to raise_error do |error|
+        expect(error).to be_a(ArgumentError)
 
-      it "should convert the keys to symbols" do
-        keys = @provider.managed_attribute_keys(existing_attributes)
-        all_symbols = keys.all? {|k| k.is_a? Symbol}
-        expect(all_symbols).to be_truthy
+        expect(error.message).to match(groups)
+        expect(error.message).to match("Groups")
       end
     end
   end
 
-  describe "#should_include?" do
-    it "should exclude keys translated into something else" do
-      managed_keys = [:rlogin]
-      @provider.class.attribute_mapping_from.stubs(:include?).with(:rlogin).returns(true)
-      @provider.class.stubs(:attribute_ignore).returns([])
-      expect(@provider.should_include?(:rlogin, managed_keys)).to be_falsey
+  describe '#parse_password' do
+    def call_parse_password
+      File.open(my_fixture('aix_passwd_file.out')) do |f|
+        provider.parse_password(f)
+      end
     end
 
-    it "should exclude keys explicitly ignored" do
-      managed_keys = [:rlogin]
-      @provider.class.attribute_mapping_from.stubs(:include?).with(:rlogin).returns(false)
-      @provider.class.stubs(:attribute_ignore).returns([:rlogin])
-      expect(@provider.should_include?(:rlogin, managed_keys)).to be_falsey
+    it "returns :absent if the user stanza doesn't exist" do
+      resource[:name] = 'nonexistent_user'
+      expect(call_parse_password).to eql(:absent)
     end
 
-    it "should exclude keys not specified in manifest" do
-      managed_keys = [:su]
-      @provider.class.attribute_mapping_from.stubs(:include?).with(:rlogin).returns(false)
-      @provider.class.stubs(:attribute_ignore).returns([])
-      expect(@provider.should_include?(:rlogin, managed_keys)).to be_falsey
+    it "returns absent if the user does not have a password" do
+      resource[:name] = 'no_password_user'
+      expect(call_parse_password).to eql(:absent)
     end
 
-    it "should include keys specified in manifest if not translated or ignored" do
-      managed_keys = [:rlogin]
-      @provider.class.attribute_mapping_from.stubs(:include?).with(:rlogin).returns(false)
-      @provider.class.stubs(:attribute_ignore).returns([])
-      expect(@provider.should_include?(:rlogin, managed_keys)).to be_truthy
+    it "returns the user's password" do
+      expect(call_parse_password).to eql('some_password')
     end
   end
-  describe "when handling passwords" do
-    let(:passwd_without_spaces) do
-        # from http://pic.dhe.ibm.com/infocenter/aix/v7r1/index.jsp?topic=%2Fcom.ibm.aix.files%2Fdoc%2Faixfiles%2Fpasswd_security.htm
-        <<-OUTPUT
-smith:
-  password = MGURSj.F056Dj
-  lastupdate = 623078865
-  flags = ADMIN,NOCHECK
-        OUTPUT
+
+  # TODO: If we move from using Mocha to rspec's mocks,
+  # or a better and more robust mocking library, we should
+  # remove #parse_password and copy over its tests to here.
+  describe '#password' do
+  end
+
+  describe '#password=' do
+    let(:mock_tempfile) do
+      mock_tempfile_obj = mock()
+      mock_tempfile_obj.stubs(:<<)
+      mock_tempfile_obj.stubs(:close)
+      mock_tempfile_obj.stubs(:delete)
+      mock_tempfile_obj.stubs(:path).returns('tempfile_path')
+
+      Tempfile.stubs(:new)
+        .with("puppet_#{provider.name}_pw", :encoding => Encoding::ASCII)
+        .returns(mock_tempfile_obj)
+
+      mock_tempfile_obj
+    end
+    let(:cmd) do
+      [provider.class.command(:chpasswd), *provider.ia_module_args, '-e', '-c']
+    end
+    let(:execute_options) do
+      {
+        :failonfail => false,
+        :combine => true,
+        :stdinfile => mock_tempfile.path
+      }
     end
 
-    let(:passwd_with_spaces) do
-        # add trailing space to the password
-        passwd_without_spaces.gsub(/password = (.*)/, 'password = \1   ')
+    it 'raises a Puppet::Error if chpasswd fails' do
+      provider.stubs(:execute).with(cmd, execute_options).returns("failed to change passwd!")
+      expect { provider.password = 'foo' }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Error)
+        expect(error.message).to match("failed to change passwd!")
+      end
     end
 
+    it "changes the user's password" do
+      provider.expects(:execute).with(cmd, execute_options).returns("")
+      provider.password = 'foo'
+    end
+
+    it "closes and deletes the tempfile" do
+      provider.stubs(:execute).with(cmd, execute_options).returns("")
 
-    it "should be able to read the hashed password" do
-      @provider.stubs(:open_security_passwd).returns(StringIO.new(passwd_without_spaces))
-      @resource.stubs(:[]).returns('smith')
+      mock_tempfile.expects(:close).times(2)
+      mock_tempfile.expects(:delete)
 
-      expect(@provider.password).to eq('MGURSj.F056Dj')
+      provider.password = 'foo'
     end
+  end
+
+  describe '#create' do
+    it 'should create the user' do
+      provider.resource.stubs(:should).with(anything).returns(nil)
+      provider.resource.stubs(:should).with(:password).returns('password')
 
-    it "should be able to read the hashed password, even with trailing spaces" do
-      @provider.stubs(:open_security_passwd).returns(StringIO.new(passwd_with_spaces))
-      @resource.stubs(:[]).returns('smith')
+      provider.expects(:execute)
+      provider.expects(:password=).with('password')
 
-      expect(@provider.password).to eq('MGURSj.F056Dj')
+      provider.create
     end
   end
 end

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

@@ -4,7 +4,7 @@ require 'etc'
 
 provider_class = Puppet::Type.type(:user).provider(:hpuxuseradd)
 
-describe provider_class, :unless => Puppet.features.microsoft_windows? do
+describe provider_class, :unless => Puppet::Util::Platform.windows? do
   let :resource do
     Puppet::Type.type(:user).new(
       :title => 'testuser',
@@ -16,6 +16,7 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
 
   it "should add -F when modifying a user" do
     resource.stubs(:allowdupe?).returns true
+    provider.stubs(:trusted).returns true
     provider.expects(:execute).with { |args| args.include?("-F") }
     provider.uid = 1000
   end
@@ -59,14 +60,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