diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 7d2e8a84c..3d37fc72e 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -1,193 +1,194 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-9-12.
 #  Copyright (c) 2006. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppettest/support/utils'
 require 'puppettest/fileparsing'
 
 module ParsedMountTesting
   include PuppetTest::Support::Utils
   include PuppetTest::FileParsing
 
   def fake_fstab
     os = Facter['operatingsystem']
     if os == "Solaris"
       name = "solaris.fstab"
     elsif os == "FreeBSD"
       name = "freebsd.fstab"
     else
       # Catchall for other fstabs
       name = "linux.fstab"
     end
     oldpath = @provider_class.default_target
     fakefile(File::join("data/types/mount", name))
   end
 
   def mkmountargs
     mount = nil
 
     if defined?(@pcount)
       @pcount += 1
     else
       @pcount = 1
     end
     args = {
       :name => "/fspuppet#{@pcount}",
       :device => "/dev/dsk#{@pcount}",
     }
 
     @provider_class.fields(:parsed).each do |field|
       args[field] = "fake#{field}#{@pcount}" unless args.include? field
     end
 
     args
   end
 
   def mkmount
     hash = mkmountargs
     #hash[:provider] = @provider_class.name
 
     fakeresource = stub :type => :mount, :name => hash[:name]
+    fakeresource.class.stubs(:key_attributes).returns([:name])
     fakeresource.stubs(:[]).with(:name).returns(hash[:name])
     fakeresource.stubs(:should).with(:target).returns(nil)
 
     mount = @provider_class.new(fakeresource)
     hash[:record_type] = :parsed
     hash[:ensure] = :present
     mount.property_hash = hash
 
     mount
   end
 
   # Here we just create a fake host type that answers to all of the methods
   # but does not modify our actual system.
   def mkfaketype
     @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
   end
 end
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
 
 describe provider_class do
   before :each do
     @mount_class = Puppet::Type.type(:mount)
     @provider_class = @mount_class.provider(:parsed)
   end
 
 
   describe provider_class do
     include ParsedMountTesting
 
     it "should be able to parse all of the example mount tabs" do
       tab = fake_fstab
       @provider = @provider_class
 
       # LAK:FIXME Again, a relatively bad test, but I don't know how to rspec-ify this.
       # I suppose this is more of an integration test?  I dunno.
       fakedataparse(tab) do
         # Now just make we've got some mounts we know will be there
         hashes = @provider_class.target_records(tab).find_all { |i| i.is_a? Hash }
         (hashes.length > 0).should be_true
         root = hashes.find { |i| i[:name] == "/" }
 
         proc { @provider_class.to_file(hashes) }.should_not raise_error
       end
     end
 
     # LAK:FIXME I can't mock Facter because this test happens at parse-time.
     it "should default to /etc/vfstab on Solaris and /etc/fstab everywhere else" do
       should = case Facter.value(:operatingsystem)
         when "Solaris"; "/etc/vfstab"
         else
           "/etc/fstab"
         end
       Puppet::Type.type(:mount).provider(:parsed).default_target.should == should
     end
 
     it "should not crash on incomplete lines in fstab" do
       parse = @provider_class.parse <<-FSTAB
 /dev/incomplete
 /dev/device       name
       FSTAB
 
       lambda{ @provider_class.to_line(parse[0]) }.should_not raise_error
     end
   end
 
   describe provider_class, " when mounting an absent filesystem" do
     include ParsedMountTesting
 
     # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
     it "should flush the fstab to disk" do
       mount = mkmount
 
       # Mark the mount as absent
       mount.property_hash[:ensure] = :absent
 
       mount.stubs(:mountcmd) # just so we don't actually try to mount anything
 
       mount.expects(:flush)
       mount.mount
     end
   end
 
   describe provider_class, " when modifying the filesystem tab" do
     include ParsedMountTesting
     before do
       Puppet.settings.stubs(:use)
       # Never write to disk, only to RAM.
       #@provider_class.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
       @provider_class.stubs(:target_object).returns(Puppet::Util::FileType.filetype(:ram).new("eh"))
       @provider_class.clear
 
       @mount = mkmount
       @target = @provider_class.default_target
     end
 
     it "should write the mount to disk when :flush is called" do
       old_text = @provider_class.target_object(@provider_class.default_target).read
 
       @mount.flush
 
       text = @provider_class.target_object(@provider_class.default_target).read
       text.should == old_text + @mount.class.to_line(@mount.property_hash) + "\n"
     end
   end
 
   describe provider_class, " when parsing information about the root filesystem" do
     confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
     include ParsedMountTesting
 
     before do
       @mount = @mount_class.new :name => "/"
       @provider = @mount.provider
     end
 
     it "should have a filesystem tab" do
       FileTest.should be_exist(@provider_class.default_target)
     end
 
     it "should find the root filesystem" do
       @provider_class.prefetch("/" => @mount)
       @mount.provider.property_hash[:ensure].should == :present
     end
 
     it "should determine that the root fs is mounted" do
       @provider_class.prefetch("/" => @mount)
       @mount.provider.should be_mounted
     end
   end
 
   describe provider_class, " when mounting and unmounting" do
     include ParsedMountTesting
 
     it "should call the 'mount' command to mount the filesystem"
 
     it "should call the 'unmount' command to unmount the filesystem"
 
     it "should specify the filesystem when remounting a filesystem"
   end
 end
diff --git a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
index 11e9233e0..2e5be165a 100755
--- a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
+++ b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
@@ -1,229 +1,230 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet_spec/files'
 require 'puppettest/support/utils'
 require 'puppettest/fileparsing'
 require 'puppettest/fakes'
 
 provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
 
 describe provider_class do
   include PuppetSpec::Files
   extend PuppetTest::Support::Utils
   include PuppetTest
   include PuppetTest::FileParsing
 
   before :each do
     @sshauthkey_class = Puppet::Type.type(:ssh_authorized_key)
     @provider = @sshauthkey_class.provider(:parsed)
     @keyfile = tmpfile('authorized_keys')
     @provider.any_instance.stubs(:target).returns @keyfile
     @user = 'random_bob'
     Puppet::Util.stubs(:uid).with(@user).returns 12345
   end
 
   after :each do
     @provider.initvars
   end
 
   def mkkey(args)
     fakeresource = fakeresource(:ssh_authorized_key, args[:name])
     fakeresource.stubs(:should).with(:user).returns @user
     fakeresource.stubs(:should).with(:target).returns @keyfile
 
     key = @provider.new(fakeresource)
     args.each do |p,v|
       key.send(p.to_s + "=", v)
     end
 
     key
   end
 
   def genkey(key)
     @provider.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     File.stubs(:chown)
     File.stubs(:chmod)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
     key.flush
     @provider.target_object(@keyfile).read
   end
 
   fakedata("data/providers/ssh_authorized_key/parsed").each { |file|
     it "should be able to parse example data in #{file}" do
       fakedataparse(file)
     end
   }
 
   it "should be able to generate a basic authorized_keys file" do
 
     key = mkkey(
       {
         :name => "Just Testing",
         :key => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
         :type => "ssh-dss",
         :ensure => :present,
 
         :options => [:absent]
     })
 
     genkey(key).should == "ssh-dss AAAAfsfddsjldjgksdflgkjsfdlgkj Just Testing\n"
   end
 
   it "should be able to generate a authorized_keys file with options" do
 
     key = mkkey(
       {
         :name => "root@localhost",
         :key => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
         :type => "ssh-rsa",
         :ensure => :present,
 
         :options => ['from="192.168.1.1"', "no-pty", "no-X11-forwarding"]
     })
 
     genkey(key).should == "from=\"192.168.1.1\",no-pty,no-X11-forwarding ssh-rsa AAAAfsfddsjldjgksdflgkjsfdlgkj root@localhost\n"
   end
 
   it "should be able to parse options containing commas via its parse_options method" do
     options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
     optionstr = options.join(", ")
 
     @provider.parse_options(optionstr).should == options
   end
 
   it "should use '' as name for entries that lack a comment" do
     line = "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAut8aOSxenjOqF527dlsdHWV4MNoAsX14l9M297+SQXaQ5Z3BedIxZaoQthkDALlV/25A1COELrg9J2MqJNQc8Xe9XQOIkBQWWinUlD/BXwoOTWEy8C8zSZPHZ3getMMNhGTBO+q/O+qiJx3y5cA4MTbw2zSxukfWC87qWwcZ64UUlegIM056vPsdZWFclS9hsROVEa57YUMrehQ1EGxT4Z5j6zIopufGFiAPjZigq/vqgcAqhAKP6yu4/gwO6S9tatBeEjZ8fafvj1pmvvIplZeMr96gHE7xS3pEEQqnB3nd4RY7AF6j9kFixnsytAUO7STPh/M3pLiVQBN89TvWPQ=="
 
     @provider.parse(line)[0][:name].should == ""
   end
 end
 
 describe provider_class do
   before :each do
     @resource = stub("resource", :name => "foo")
     @resource.stubs(:[]).returns "foo"
+    @resource.class.stubs(:key_attributes).returns( [:name] )
 
     @provider = provider_class.new(@resource)
     provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
   end
 
   describe "when flushing" do
     before :each do
       # Stub file and directory operations
       Dir.stubs(:mkdir)
       File.stubs(:chmod)
       File.stubs(:chown)
     end
 
     describe "and both a user and a target have been specified" do
       before :each do
         Puppet::Util.stubs(:uid).with("random_bob").returns 12345
         @resource.stubs(:should).with(:user).returns "random_bob"
         target = "/tmp/.ssh_dir/place_to_put_authorized_keys"
         @resource.stubs(:should).with(:target).returns target
       end
 
       it "should create the directory" do
         File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
         Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0700)
         @provider.flush
       end
 
       it "should chown the directory to the user" do
         uid = Puppet::Util.uid("random_bob")
         File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir")
         @provider.flush
       end
 
       it "should chown the key file to the user" do
         uid = Puppet::Util.uid("random_bob")
         File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider.flush
       end
 
       it "should chmod the key file to 0600" do
         File.expects(:chmod).with(0600, "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider.flush
       end
     end
 
     describe "and a user has been specified with no target" do
       before :each do
         @resource.stubs(:should).with(:user).returns "nobody"
         @resource.stubs(:should).with(:target).returns nil
         #
         # I'd like to use random_bob here and something like
         #
         #    File.stubs(:expand_path).with("~random_bob/.ssh").returns "/users/r/random_bob/.ssh"
         #
         # but mocha objects strenuously to stubbing File.expand_path
         # so I'm left with using nobody.
         @dir = File.expand_path("~nobody/.ssh")
       end
 
       it "should create the directory if it doesn't exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).with(@dir,0700)
         @provider.flush
       end
 
       it "should not create or chown the directory if it already exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).never
         @provider.flush
       end
 
       it "should chown the directory to the user if it creates it" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.stubs(:mkdir).with(@dir,0700)
         uid = Puppet::Util.uid("nobody")
         File.expects(:chown).with(uid, nil, @dir)
         @provider.flush
       end
 
       it "should not create or chown the directory if it already exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).never
         File.expects(:chown).never
         @provider.flush
       end
 
       it "should chown the key file to the user" do
         uid = Puppet::Util.uid("nobody")
         File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh/authorized_keys"))
         @provider.flush
       end
 
       it "should chmod the key file to 0600" do
         File.expects(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
         @provider.flush
       end
     end
 
     describe "and a target has been specified with no user" do
       before :each do
         @resource.stubs(:should).with(:user).returns nil
         @resource.stubs(:should).with(:target).returns("/tmp/.ssh_dir/place_to_put_authorized_keys")
       end
 
       it "should raise an error" do
         proc { @provider.flush }.should raise_error
       end
     end
 
     describe "and a invalid user has been specified with no target" do
       before :each do
         @resource.stubs(:should).with(:user).returns "thisusershouldnotexist"
         @resource.stubs(:should).with(:target).returns nil
       end
 
       it "should catch an exception and raise a Puppet error" do
         lambda { @provider.flush }.should raise_error(Puppet::Error)
       end
     end
 
   end
 end