diff --git a/spec/unit/provider/host/parsed_spec.rb b/spec/unit/provider/host/parsed_spec.rb
index 3ed479974..048d77ba2 100755
--- a/spec/unit/provider/host/parsed_spec.rb
+++ b/spec/unit/provider/host/parsed_spec.rb
@@ -1,197 +1,198 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+require 'shared_behaviours/all_parsedfile_providers'
 
 require 'puppet_spec/files'
 
 provider_class = Puppet::Type.type(:host).provider(:parsed)
 
 describe provider_class do
   include PuppetSpec::Files
 
   before do
     @host_class = Puppet::Type.type(:host)
     @provider = @host_class.provider(:parsed)
     @hostfile = tmpfile('hosts')
     @provider.any_instance.stubs(:target).returns @hostfile
   end
 
   after :each do
     @provider.initvars
   end
 
   def mkhost(args)
     hostresource = Puppet::Type::Host.new(:name => args[:name])
     hostresource.stubs(:should).with(:target).returns @hostfile
 
     # Using setters of provider to build our testobject
     # Note: We already proved, that in case of host_aliases
     # the provider setter "host_aliases=(value)" will be
     # called with the joined array, so we just simulate that
     host = @provider.new(hostresource)
     args.each do |property,value|
       value = value.join(" ") if property == :host_aliases and value.is_a?(Array)
       host.send("#{property}=", value)
     end
     host
   end
 
   def genhost(host)
     @provider.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     File.stubs(:chown)
     File.stubs(:chmod)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
     host.flush
     @provider.target_object(@hostfile).read
   end
 
   describe "when parsing a line with ip and hostname" do
 
     it "should parse an ipv4 from the first field" do
       @provider.parse_line("127.0.0.1    localhost")[:ip].should == "127.0.0.1"
     end
 
     it "should parse an ipv6 from the first field" do
       @provider.parse_line("::1     localhost")[:ip].should == "::1"
     end
 
     it "should parse the name from the second field" do
       @provider.parse_line("::1     localhost")[:name].should == "localhost"
     end
 
     it "should set an empty comment" do
       @provider.parse_line("::1     localhost")[:comment].should == ""
     end
 
     it "should set host_aliases to :absent" do
       @provider.parse_line("::1     localhost")[:host_aliases].should == :absent
     end
 
   end
 
   describe "when parsing a line with ip, hostname and comment" do
     before do
       @testline = "127.0.0.1   localhost # A comment with a #-char"
     end
 
     it "should parse the ip from the first field" do
       @provider.parse_line(@testline)[:ip].should == "127.0.0.1"
     end
 
     it "should parse the hostname from the second field" do
       @provider.parse_line(@testline)[:name].should == "localhost"
     end
 
     it "should parse the comment after the first '#' character" do
       @provider.parse_line(@testline)[:comment].should == 'A comment with a #-char'
     end
 
   end
 
   describe "when parsing a line with ip, hostname and aliases" do
 
     it "should parse alias from the third field" do
       @provider.parse_line("127.0.0.1   localhost   localhost.localdomain")[:host_aliases].should == "localhost.localdomain"
     end
 
     it "should parse multiple aliases" do
       @provider.parse_line("127.0.0.1 host alias1 alias2")[:host_aliases].should == 'alias1 alias2'
       @provider.parse_line("127.0.0.1 host alias1\talias2")[:host_aliases].should == 'alias1 alias2'
       @provider.parse_line("127.0.0.1 host alias1\talias2   alias3")[:host_aliases].should == 'alias1 alias2 alias3'
     end
 
   end
 
   describe "when parsing a line with ip, hostname, aliases and comment" do
 
     before do
       # Just playing with a few different delimiters
       @testline = "127.0.0.1\t   host  alias1\talias2   alias3   #   A comment with a #-char"
     end
 
     it "should parse the ip from the first field" do
       @provider.parse_line(@testline)[:ip].should == "127.0.0.1"
     end
 
     it "should parse the hostname from the second field" do
       @provider.parse_line(@testline)[:name].should == "host"
     end
 
     it "should parse all host_aliases from the third field" do
       @provider.parse_line(@testline)[:host_aliases].should == 'alias1 alias2 alias3'
     end
 
     it "should parse the comment after the first '#' character" do
       @provider.parse_line(@testline)[:comment].should == 'A comment with a #-char'
     end
 
   end
 
   describe "when operating on /etc/hosts like files" do
     it_should_behave_like "all parsedfile providers",
       provider_class, my_fixtures('valid*')
 
     it "should be able to generate a simple hostfile entry" do
       host = mkhost(
         :name   => 'localhost',
         :ip     => '127.0.0.1',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost\n"
     end
 
     it "should be able to generate an entry with one alias" do
       host = mkhost(
         :name   => 'localhost.localdomain',
         :ip     => '127.0.0.1',
         :host_aliases => 'localhost',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost.localdomain\tlocalhost\n"
     end
 
     it "should be able to generate an entry with more than one alias" do
       host = mkhost(
         :name       => 'host',
         :ip         => '192.0.0.1',
         :host_aliases => [ 'a1','a2','a3','a4' ],
         :ensure     => :present
       )
       genhost(host).should == "192.0.0.1\thost\ta1 a2 a3 a4\n"
     end
 
     it "should be able to generate a simple hostfile entry with comments" do
       host = mkhost(
         :name    => 'localhost',
         :ip      => '127.0.0.1',
         :comment => 'Bazinga!',
         :ensure  => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost\t# Bazinga!\n"
     end
 
     it "should be able to generate an entry with one alias and a comment" do
       host = mkhost(
         :name   => 'localhost.localdomain',
         :ip     => '127.0.0.1',
         :host_aliases => 'localhost',
         :comment => 'Bazinga!',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost.localdomain\tlocalhost\t# Bazinga!\n"
     end
 
     it "should be able to generate an entry with more than one alias and a comment" do
       host = mkhost(
         :name         => 'host',
         :ip           => '192.0.0.1',
         :host_aliases => [ 'a1','a2','a3','a4' ],
         :comment      => 'Bazinga!',
         :ensure       => :present
       )
       genhost(host).should == "192.0.0.1\thost\ta1 a2 a3 a4\t# Bazinga!\n"
     end
 
   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 6d67ee3bb..7a1bd77f4 100755
--- a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
+++ b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
@@ -1,221 +1,211 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
-
+require 'shared_behaviours/all_parsedfile_providers'
 require 'puppet_spec/files'
-require 'puppettest/fakes'
 
 provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
 
 describe provider_class do
   include PuppetSpec::Files
-  include PuppetTest
 
   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[:target] = @keyfile
+    args[:user]   = @user
+    resource = Puppet::Type.type(:ssh_authorized_key).new(args)
+    key = @provider.new(resource)
     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
 
   it_should_behave_like "all parsedfile providers", provider_class
 
   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]
-    })
+    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"]
-    })
+    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"
 
     @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