diff --git a/lib/puppet/provider/user/windows_adsi.rb b/lib/puppet/provider/user/windows_adsi.rb
index 6b0a9bce7..045a84bdb 100644
--- a/lib/puppet/provider/user/windows_adsi.rb
+++ b/lib/puppet/provider/user/windows_adsi.rb
@@ -1,87 +1,88 @@
 require 'puppet/util/adsi'
 
 Puppet::Type.type(:user).provide :windows_adsi do
   desc "User management for Windows."
 
   defaultfor :operatingsystem => :windows
   confine    :operatingsystem => :windows
 
   has_features :manages_homedir, :manages_passwords
 
   def user
     @user ||= Puppet::Util::ADSI::User.new(@resource[:name])
   end
 
   def groups
     user.groups.join(',')
   end
 
   def groups=(groups)
     user.set_groups(groups, @resource[:membership] == :minimum)
   end
 
   def create
     @user = Puppet::Util::ADSI::User.create(@resource[:name])
+    @user.password = @resource[:password]
     @user.commit
 
     [:comment, :home, :groups].each do |prop|
       send("#{prop}=", @resource[prop]) if @resource[prop]
     end
   end
 
   def exists?
     Puppet::Util::ADSI::User.exists?(@resource[:name])
   end
 
   def delete
     Puppet::Util::ADSI::User.delete(@resource[:name])
   end
 
   # Only flush if we created or modified a user, not deleted
   def flush
     @user.commit if @user
   end
 
   def comment
     user['Description']
   end
 
   def comment=(value)
     user['Description'] = value
   end
 
   def home
     user['HomeDirectory']
   end
 
   def home=(value)
     user['HomeDirectory'] = value
   end
 
   def password
     user.password_is?( @resource[:password] ) ? @resource[:password] : :absent
   end
 
   def password=(value)
     user.password = value
   end
 
   def uid
     Puppet::Util::ADSI.sid_for_account(@resource[:name])
   end
 
   def uid=(value)
     fail "uid is read-only"
   end
 
   [:gid, :shell].each do |prop|
     define_method(prop) { nil }
     define_method("#{prop}=") do |v|
       fail "No support for managing property #{prop} of user #{@resource[:name]} on Windows"
     end
   end
 
   def self.instances
     Puppet::Util::ADSI::User.map { |u| new(:ensure => :present, :name => u.name) }
   end
 end
diff --git a/spec/unit/provider/user/windows_adsi_spec.rb b/spec/unit/provider/user/windows_adsi_spec.rb
index 6eff947e0..23fba9983 100755
--- a/spec/unit/provider/user/windows_adsi_spec.rb
+++ b/spec/unit/provider/user/windows_adsi_spec.rb
@@ -1,150 +1,151 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Type.type(:user).provider(:windows_adsi) do
   let(:resource) do
     Puppet::Type.type(:user).new(
       :title => 'testuser',
       :comment => 'Test J. User',
       :provider => :windows_adsi
     )
   end
 
   let(:provider) { resource.provider }
 
   let(:connection) { stub 'connection' }
 
   before :each do
     Puppet::Util::ADSI.stubs(:computer_name).returns('testcomputername')
     Puppet::Util::ADSI.stubs(:connect).returns connection
   end
 
   describe ".instances" do
     it "should enumerate all users" do
       names = ['user1', 'user2', 'user3']
       stub_users = names.map{|n| stub(:name => n)}
 
       connection.stubs(:execquery).with("select * from win32_useraccount").returns(stub_users)
 
       described_class.instances.map(&:name).should =~ names
     end
   end
 
   it "should provide access to a Puppet::Util::ADSI::User object" do
     provider.user.should be_a(Puppet::Util::ADSI::User)
   end
 
   describe "when managing groups" do
     it 'should return the list of groups as a comma-separated list' do
       provider.user.stubs(:groups).returns ['group1', 'group2', 'group3']
 
       provider.groups.should == 'group1,group2,group3'
     end
 
     it "should return absent if there are no groups" do
       provider.user.stubs(:groups).returns []
 
       provider.groups.should == ''
     end
 
     it 'should be able to add a user to a set of groups' do
       resource[:membership] = :minimum
       provider.user.expects(:set_groups).with('group1,group2', true)
 
       provider.groups = 'group1,group2'
 
       resource[:membership] = :inclusive
       provider.user.expects(:set_groups).with('group1,group2', false)
 
       provider.groups = 'group1,group2'
     end
   end
 
   describe "when creating a user" do
     it "should create the user on the system and set its other properties" do
       resource[:groups]     = ['group1', 'group2']
       resource[:membership] = :inclusive
       resource[:comment]    = 'a test user'
       resource[:home]       = 'C:\Users\testuser'
 
       user = stub 'user'
       Puppet::Util::ADSI::User.expects(:create).with('testuser').returns user
 
       user.stubs(:groups).returns(['group2', 'group3'])
 
       create = sequence('create')
+      user.expects(:password=).in_sequence(create)
       user.expects(:commit).in_sequence(create)
       user.expects(:set_groups).with('group1,group2', false).in_sequence(create)
       user.expects(:[]=).with('Description', 'a test user')
       user.expects(:[]=).with('HomeDirectory', 'C:\Users\testuser')
 
       provider.create
     end
 
     it "should set a user's password" do
       provider.user.expects(:password=).with('plaintextbad')
 
       provider.password = "plaintextbad"
     end
 
     it "should test a valid user password" do
       resource[:password] = 'plaintext'
       provider.user.expects(:password_is?).with('plaintext').returns true
 
       provider.password.should == 'plaintext'
 
     end
 
     it "should test a bad user password" do
       resource[:password] = 'plaintext'
       provider.user.expects(:password_is?).with('plaintext').returns false
 
       provider.password.should == :absent
     end
 
     it 'should not create a user if a group by the same name exists' do
       Puppet::Util::ADSI::User.expects(:create).with('testuser').raises( Puppet::Error.new("Cannot create user if group 'testuser' exists.") )
       expect{ provider.create }.to raise_error( Puppet::Error,
         /Cannot create user if group 'testuser' exists./ )
     end
   end
 
   it 'should be able to test whether a user exists' do
     Puppet::Util::ADSI.stubs(:connect).returns stub('connection')
     provider.should be_exists
 
     Puppet::Util::ADSI.stubs(:connect).returns nil
     provider.should_not be_exists
   end
 
   it 'should be able to delete a user' do
     connection.expects(:Delete).with('user', 'testuser')
 
     provider.delete
   end
 
   it "should commit the user when flushed" do
     provider.user.expects(:commit)
 
     provider.flush
   end
 
   it "should return the user's SID as uid" do
     Puppet::Util::ADSI.expects(:sid_for_account).with('testuser').returns('S-1-5-21-1362942247-2130103807-3279964888-1111')
 
     provider.uid.should == 'S-1-5-21-1362942247-2130103807-3279964888-1111'
   end
 
   it "should fail when trying to manage the uid property" do
     provider.expects(:fail).with { |msg| msg =~ /uid is read-only/ }
     provider.send(:uid=, 500)
   end
 
   [:gid, :shell].each do |prop|
     it "should fail when trying to manage the #{prop} property" do
       provider.expects(:fail).with { |msg| msg =~ /No support for managing property #{prop}/ }
       provider.send("#{prop}=", 'foo')
     end
   end
 end