diff --git a/lib/puppet/type/file/mode.rb b/lib/puppet/type/file/mode.rb
index 631327697..b246652a0 100755
--- a/lib/puppet/type/file/mode.rb
+++ b/lib/puppet/type/file/mode.rb
@@ -1,77 +1,85 @@
 # Manage file modes.  This state should support different formats
 # for specification (e.g., u+rwx, or -0011), but for now only supports
 # specifying the full mode.
 module Puppet
   Puppet::Type.type(:file).newproperty(:mode) do
     desc "Mode the file should be.  Currently relatively limited:
       you must specify the exact mode the file should be.
 
       Note that when you set the mode of a directory, Puppet always
       sets the search/traverse (1) bit anywhere the read (4) bit is set.
       This is almost always what you want: read allows you to list the
       entries in a directory, and search/traverse allows you to access
       (read/write/execute) those entries.)  Because of this feature, you
       can recursively make a directory and all of the files in it
       world-readable by setting e.g.:
 
           file { '/some/dir':
             mode    => 644,
             recurse => true,
           }
 
       In this case all of the files underneath `/some/dir` will have
       mode 644, and all of the directories will have mode 755."
 
     validate do |value|
       if value.is_a?(String) and value !~ /^[0-7]+$/
         raise Puppet::Error, "File modes can only be octal numbers, not #{should.inspect}"
       end
     end
 
     munge do |should|
       if should.is_a?(String)
         should.to_i(8).to_s(8)
       else
         should.to_s(8)
       end
     end
 
     # If we're a directory, we need to be executable for all cases
     # that are readable.  This should probably be selectable, but eh.
     def dirmask(value)
       if FileTest.directory?(resource[:path])
         value = value.to_i(8)
         value |= 0100 if value & 0400 != 0
         value |= 010 if value & 040 != 0
         value |= 01 if value & 04 != 0
         value = value.to_s(8)
       end
 
       value
     end
 
     # If we're not following links and we're a link, then we just turn
     # off mode management entirely.
     def insync?(currentvalue)
       if stat = @resource.stat and stat.ftype == "link" and @resource[:links] != :follow
         self.debug "Not managing symlink mode"
         return true
       else
         return super(currentvalue)
       end
     end
 
     # Ideally, dirmask'ing could be done at munge time, but we don't know if 'ensure'
     # will eventually be a directory or something else. And unfortunately, that logic
     # depends on the ensure, source, and target properties. So rather than duplicate
     # that logic, and get it wrong, we do dirmask during retrieve, after 'ensure' has
     # been synced.
     def retrieve
       if @resource.stat
         @should &&= @should.collect { |s| self.dirmask(s) }
       end
 
       super
     end
+
+    def should_to_s(should_value)
+      should_value.rjust(4,"0")
+    end
+
+    def is_to_s(currentvalue)
+      currentvalue.rjust(4,"0")
+    end
   end
 end
diff --git a/spec/unit/type/file/mode_spec.rb b/spec/unit/type/file/mode_spec.rb
index 8783a8464..2c6772aba 100755
--- a/spec/unit/type/file/mode_spec.rb
+++ b/spec/unit/type/file/mode_spec.rb
@@ -1,106 +1,142 @@
 #!/usr/bin/env rspec
 
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:mode) do
   include PuppetSpec::Files
 
   let(:path) { tmpfile('mode_spec') }
   let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => 0644 }
   let(:mode) { resource.property(:mode) }
 
   describe "#validate" do
     it "should accept values specified as integers" do
       expect { mode.value = 0755 }.not_to raise_error
     end
 
     it "should accept values specified as octal numbers in strings" do
       expect { mode.value = '0755' }.not_to raise_error
     end
 
     it "should not accept strings other than octal numbers" do
       expect do
         mode.value = 'readable please!'
       end.to raise_error(Puppet::Error, /File modes can only be octal numbers/)
     end
   end
 
   describe "#munge" do
     # This is sort of a redundant test, but its spec is important.
     it "should return the value as a string" do
       mode.munge('0644').should be_a(String)
     end
 
     it "should accept strings as arguments" do
       mode.munge('0644').should == '644'
     end
 
     it "should accept integers are arguments" do
       mode.munge(0644).should == '644'
     end
   end
 
   describe "#dirmask" do
     before :each do
       Dir.mkdir(path)
     end
 
     it "should add execute bits corresponding to read bits for directories" do
       mode.dirmask('0644').should == '755'
     end
 
     it "should not add an execute bit when there is no read bit" do
       mode.dirmask('0600').should == '700'
     end
 
     it "should not add execute bits for files that aren't directories" do
       resource[:path] = tmpfile('other_file')
       mode.dirmask('0644').should == '0644'
     end
   end
 
   describe "#insync?" do
     it "should return true if the mode is correct" do
       FileUtils.touch(path)
 
       mode.must be_insync('644')
     end
 
     it "should return false if the mode is incorrect" do
       FileUtils.touch(path)
 
       mode.must_not be_insync('755')
     end
 
     it "should return true if the file is a link and we are managing links", :unless => Puppet.features.microsoft_windows? do
       File.symlink('anything', path)
 
       mode.must be_insync('644')
     end
   end
 
   describe "#retrieve" do
     it "should return absent if the resource doesn't exist" do
       resource[:path] = File.expand_path("/does/not/exist")
       mode.retrieve.should == :absent
     end
 
     it "should retrieve the directory mode from the provider" do
       Dir.mkdir(path)
 
       mode.expects(:dirmask).with('644').returns '755'
       resource.provider.expects(:mode).returns '755'
 
       mode.retrieve.should == '755'
     end
 
     it "should retrieve the file mode from the provider" do
       FileUtils.touch(path)
 
       mode.expects(:dirmask).with('644').returns '644'
       resource.provider.expects(:mode).returns '644'
 
       mode.retrieve.should == '644'
     end
   end
+
+  describe '#should_to_s' do
+    describe 'with a 3-digit mode' do
+      it 'returns a 4-digit mode with a leading zero' do
+        mode.should_to_s('755').should == '0755'
+      end
+    end
+
+    describe 'with a 4-digit mode' do
+      it 'returns the 4-digit mode when the first digit is a zero' do
+        mode.should_to_s('0755').should == '0755'
+      end
+
+      it 'returns the 4-digit mode when the first digit is not a zero' do
+        mode.should_to_s('1755').should == '1755'
+      end
+    end
+  end
+
+  describe '#is_to_s' do
+    describe 'with a 3-digit mode' do
+      it 'returns a 4-digit mode with a leading zero' do
+        mode.is_to_s('755').should == '0755'
+      end
+    end
+
+    describe 'with a 4-digit mode' do
+      it 'returns the 4-digit mode when the first digit is a zero' do
+        mode.is_to_s('0755').should == '0755'
+      end
+
+      it 'returns the 4-digit mode when the first digit is not a zero' do
+        mode.is_to_s('1755').should == '1755'
+      end
+    end
+  end
 end