diff --git a/lib/puppet/type/mount.rb b/lib/puppet/type/mount.rb
index d048c90f1..e8c6b3290 100755
--- a/lib/puppet/type/mount.rb
+++ b/lib/puppet/type/mount.rb
@@ -1,224 +1,224 @@
 module Puppet
   # We want the mount to refresh when it changes.
   newtype(:mount, :self_refresh => true) do
     @doc = "Manages mounted filesystems, including putting mount
       information into the mount table. The actual behavior depends
       on the value of the 'ensure' parameter.
 
       Note that if a `mount` receives an event from another resource,
       it will try to remount the filesystems if `ensure` is set to `mounted`."
 
     feature :refreshable, "The provider can remount the filesystem.",
       :methods => [:remount]
 
     # Use the normal parent class, because we actually want to
     # call code when sync is called.
     newproperty(:ensure) do
       desc "Control what to do with this mount. Set this attribute to
         `umounted` to make sure the filesystem is in the filesystem table
         but not mounted (if the filesystem is currently mounted, it will be unmounted).  Set it to `absent` to unmount (if necessary) and remove
         the filesystem from the fstab.  Set to `mounted` to add it to the
         fstab and mount it. Set to `present` to add to fstab but not change
         mount/unmount status"
 
       newvalue(:defined) do
         provider.create
         return :mount_created
       end
 
       aliasvalue :present, :defined
 
       newvalue(:unmounted) do
         if provider.mounted?
           syncothers
           provider.unmount
           return :mount_unmounted
         else
           provider.create
           return :mount_created
         end
       end
 
       newvalue(:absent, :event => :mount_deleted) do
         provider.unmount if provider.mounted?
 
         provider.destroy
       end
 
       newvalue(:mounted, :event => :mount_mounted) do
         # Create the mount point if it does not already exist.
         current_value = self.retrieve
         provider.create if current_value.nil? or current_value == :absent
 
         syncothers
 
         # The fs can be already mounted if it was absent but mounted
         provider.mount unless provider.mounted?
       end
 
       def insync?(is)
         if should == :defined and is != :absent
           true
         else
           super
         end
       end
 
       def retrieve
         # We need to special case :mounted; if we're absent, we still
         # want
         curval = super()
         if curval == :absent
           return :absent
         elsif provider.mounted?
           return :mounted
         else
           return :unmounted
         end
       end
 
       def syncothers
         # We have to flush any changes to disk.
         currentvalues = @resource.retrieve_resource
 
         # Determine if there are any out-of-sync properties.
         oos = @resource.send(:properties).find_all do |prop|
           unless currentvalues.include?(prop)
             raise Puppet::DevError, "Parent has property %s but it doesn't appear in the current values", [prop.name]
           end
           if prop.name == :ensure
             false
           else
             ! prop.insync?(currentvalues[prop])
           end
         end.each { |prop| prop.sync }.length
         @resource.flush if oos > 0
       end
     end
 
     newproperty(:device) do
       desc "The device providing the mount.  This can be whatever
         device is supporting by the mount, including network
         devices or devices specified by UUID rather than device
         path, depending on the operating system."
     end
 
     # Solaris specifies two devices, not just one.
     newproperty(:blockdevice) do
       desc "The device to fsck.  This is property is only valid
         on Solaris, and in most cases will default to the correct
         value."
 
       # Default to the device but with "dsk" replaced with "rdsk".
       defaultto do
         if Facter["operatingsystem"].value == "Solaris"
           device = @resource.value(:device)
           if device =~ %r{/dsk/}
             device.sub(%r{/dsk/}, "/rdsk/")
           else
             nil
           end
         else
           nil
         end
       end
     end
 
     newproperty(:fstype) do
       desc "The mount type.  Valid values depend on the
         operating system.  This is a required option."
     end
 
     newproperty(:options) do
       desc "Mount options for the mounts, as they would
         appear in the fstab."
     end
 
     newproperty(:pass) do
       desc "The pass in which the mount is checked."
 
       defaultto {
         0 if @resource.managed?
       }
     end
 
     newproperty(:atboot) do
       desc "Whether to mount the mount at boot.  Not all platforms
         support this."
     end
 
     newproperty(:dump) do
       desc "Whether to dump the mount.  Not all platform support this.
         Valid values are `1` or `0`. or `2` on FreeBSD, Default is `0`."
 
       if Facter["operatingsystem"].value == "FreeBSD"
         newvalue(%r{(0|1|2)})
       else
         newvalue(%r{(0|1)})
       end
 
       newvalue(%r{(0|1)})
 
       defaultto {
         0 if @resource.managed?
       }
     end
 
     newproperty(:target) do
       desc "The file in which to store the mount table.  Only used by
         those providers that write to disk."
 
       defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
           @resource.class.defaultprovider.default_target
         else
           nil
         end
       }
     end
 
     newparam(:name) do
       desc "The mount path for the mount."
 
       isnamevar
     end
 
     newparam(:path) do
       desc "The deprecated name for the mount point.  Please use `name` now."
 
       def value=(value)
         warning "'path' is deprecated for mounts.  Please use 'name'."
         @resource[:name] = value
         super
       end
     end
 
     newparam(:remounts) do
       desc "Whether the mount can be remounted  `mount -o remount`.  If
         this is false, then the filesystem will be unmounted and remounted
         manually, which is prone to failure."
 
       newvalues(:true, :false)
       defaultto do
         case Facter.value(:operatingsystem)
         when "FreeBSD", "Darwin"
           false
         else
           true
         end
       end
     end
 
     def refresh
       # Only remount if we're supposed to be mounted.
-      provider.remount if self.should(:fstype) != "swap" and provider.mounted?
+      provider.remount if self.should(:fstype) != "swap" and self.should(:ensure) == :mounted
     end
 
     def value(name)
       name = symbolize(name)
       ret = nil
       if property = @parameters[name]
         return property.value
       end
     end
   end
 end
diff --git a/spec/unit/type/mount_spec.rb b/spec/unit/type/mount_spec.rb
index ce82cb516..4aa9baf70 100755
--- a/spec/unit/type/mount_spec.rb
+++ b/spec/unit/type/mount_spec.rb
@@ -1,261 +1,283 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:mount) do
   it "should have a :refreshable feature that requires the :remount method" do
     Puppet::Type.type(:mount).provider_feature(:refreshable).methods.should == [:remount]
   end
 
   it "should have no default value for :ensure" do
     mount = Puppet::Type.type(:mount).new(:name => "yay")
     mount.should(:ensure).should be_nil
   end
 end
 
 describe Puppet::Type.type(:mount), "when validating attributes" do
   [:name, :remounts].each do |param|
     it "should have a #{param} parameter" do
       Puppet::Type.type(:mount).attrtype(param).should == :param
     end
   end
 
   [:ensure, :device, :blockdevice, :fstype, :options, :pass, :dump, :atboot, :target].each do |param|
     it "should have a #{param} property" do
       Puppet::Type.type(:mount).attrtype(param).should == :property
     end
   end
 end
 
 describe Puppet::Type.type(:mount)::Ensure, "when validating values" do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil
     Puppet::Type.type(:mount).defaultprovider.expects(:new).returns(@provider)
   end
 
   it "should alias :present to :defined as a value to :ensure" do
     mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :present)
     mount.should(:ensure).should == :defined
   end
 
   it "should support :unmounted as a value to :ensure" do
     mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :unmounted)
     mount.should(:ensure).should == :unmounted
   end
 
   it "should support :absent as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :absent)
   end
 
   it "should support :mounted as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
   end
 end
 
 describe Puppet::Type.type(:mount)::Ensure do
   before :each do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
     @mount = Puppet::Type.type(:mount).new(:name => "yay", :check => :ensure)
 
     @ensure = @mount.property(:ensure)
   end
 
   def mount_stub(params)
     Puppet::Type.type(:mount).validproperties.each do |prop|
       unless params[prop]
         params[prop] = :absent
         @mount[prop] = :absent
       end
     end
 
     params.each do |param, value|
       @provider.stubs(param).returns(value)
     end
   end
 
   describe Puppet::Type.type(:mount)::Ensure, "when retrieving its current state" do
 
     it "should return the provider's value if it is :absent" do
       @provider.expects(:ensure).returns(:absent)
       @ensure.retrieve.should == :absent
     end
 
     it "should return :mounted if the provider indicates it is mounted and the value is not :absent" do
       @provider.expects(:ensure).returns(:present)
       @provider.expects(:mounted?).returns(true)
       @ensure.retrieve.should == :mounted
     end
 
     it "should return :unmounted if the provider indicates it is not mounted and the value is not :absent" do
       @provider.expects(:ensure).returns(:present)
       @provider.expects(:mounted?).returns(false)
       @ensure.retrieve.should == :unmounted
     end
   end
 
   describe Puppet::Type.type(:mount)::Ensure, "when changing the host" do
 
     it "should destroy itself if it should be absent" do
       @provider.stubs(:mounted?).returns(false)
       @provider.expects(:destroy)
       @ensure.should = :absent
       @ensure.sync
     end
 
     it "should unmount itself before destroying if it is mounted and should be absent" do
       @provider.expects(:mounted?).returns(true)
       @provider.expects(:unmount)
       @provider.expects(:destroy)
       @ensure.should = :absent
       @ensure.sync
     end
 
     it "should create itself if it is absent and should be defined" do
       @provider.stubs(:ensure).returns(:absent)
       @provider.stubs(:mounted?).returns(true)
 
       @provider.stubs(:mounted?).returns(false)
       @provider.expects(:create)
       @ensure.should = :defined
       @ensure.sync
     end
 
     it "should not unmount itself if it is mounted and should be defined" do
       @provider.stubs(:ensure).returns(:mounted)
       @provider.stubs(:mounted?).returns(true)
 
       @provider.stubs(:create)
       @provider.expects(:mount).never
       @provider.expects(:unmount).never
       @ensure.should = :defined
       @ensure.sync
     end
 
     it "should not mount itself if it is unmounted and should be defined" do
       @provider.stubs(:ensure).returns(:unmounted)
       @provider.stubs(:mounted?).returns(false)
 
       @ensure.stubs(:syncothers)
       @provider.stubs(:create)
       @provider.expects(:mount).never
       @provider.expects(:unmount).never
       @ensure.should = :present
       @ensure.sync
     end
 
     it "should unmount itself if it is mounted and should be unmounted" do
       @provider.stubs(:ensure).returns(:present)
       @provider.stubs(:mounted?).returns(true)
 
       @ensure.stubs(:syncothers)
       @provider.expects(:unmount)
       @ensure.should = :unmounted
       @ensure.sync
     end
 
     it "should create and mount itself if it does not exist and should be mounted" do
       @provider.stubs(:ensure).returns(:absent)
       @provider.stubs(:mounted?).returns(false)
       @provider.expects(:create)
       @ensure.stubs(:syncothers)
       @provider.expects(:mount)
       @ensure.should = :mounted
       @ensure.sync
     end
 
     it "should mount itself if it is present and should be mounted" do
       @provider.stubs(:ensure).returns(:present)
       @provider.stubs(:mounted?).returns(false)
       @ensure.stubs(:syncothers)
       @provider.expects(:mount)
       @ensure.should = :mounted
       @ensure.sync
     end
 
     it "should create but not mount itself if it is absent and mounted and should be mounted" do
       @provider.stubs(:ensure).returns(:absent)
       @provider.stubs(:mounted?).returns(true)
       @ensure.stubs(:syncothers)
       @provider.expects(:create)
       @ensure.should = :mounted
       @ensure.sync
     end
 
     it "should be insync if it is mounted and should be defined" do
       @ensure.should = :defined
       @ensure.insync?(:mounted).should == true
     end
 
     it "should be insync if it is unmounted and should be defined" do
       @ensure.should = :defined
       @ensure.insync?(:unmounted).should == true
     end
 
     it "should be insync if it is mounted and should be present" do
       @ensure.should = :present
       @ensure.insync?(:mounted).should == true
     end
 
     it "should be insync if it is unmounted and should be present" do
       @ensure.should = :present
       @ensure.insync?(:unmounted).should == true
     end
   end
 
-  describe Puppet::Type.type(:mount), "when responding to events" do
+  describe Puppet::Type.type(:mount), "when responding to refresh" do
 
-    it "should remount if it is currently mounted" do
-      @provider.expects(:mounted?).returns(true)
+    it "should remount if it is supposed to be mounted" do
+      @mount[:ensure] = "mounted"
       @provider.expects(:remount)
 
       @mount.refresh
     end
 
-    it "should not remount if it is not currently mounted" do
-      @provider.expects(:mounted?).returns(false)
+    it "should not remount if it is supposed to be present" do
+      @mount[:ensure] = "present"
+      @provider.expects(:remount).never
+
+      @mount.refresh
+    end
+
+    it "should not remount if it is supposed to be absent" do
+      @mount[:ensure] = "absent"
+      @provider.expects(:remount).never
+
+      @mount.refresh
+    end
+
+    it "should not remount if it is supposed to be defined" do
+      @mount[:ensure] = "defined"
+      @provider.expects(:remount).never
+
+      @mount.refresh
+    end
+
+    it "should not remount if it is supposed to be unmounted" do
+      @mount[:ensure] = "unmounted"
       @provider.expects(:remount).never
 
       @mount.refresh
     end
 
     it "should not remount swap filesystems" do
+      @mount[:ensure] = "mounted"
       @mount[:fstype] = "swap"
       @provider.expects(:remount).never
 
       @mount.refresh
     end
   end
 end
 
 describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :remount => nil
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
     @mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
 
     {:device => "/foo/bar", :blockdevice => "/other/bar", :target => "/what/ever", :fstype => 'eh', :options => "", :pass => 0, :dump => 0, :atboot => 0,
       :ensure => :mounted}.each do
       |param, value|
       @mount.provider.stubs(param).returns value
       @mount[param] = value
     end
 
     @mount.provider.stubs(:mounted?).returns true
 
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
 
     @catalog = Puppet::Resource::Catalog.new
     @catalog.add_resource @mount
   end
 
   it "should use the provider to change the dump value" do
     @mount.provider.expects(:dump).returns 0
     @mount.provider.expects(:dump=).with(1)
 
     @mount[:dump] = 1
 
     @catalog.apply
   end
 end