Merge branch '0.24.x'

Conflicts:

	lib/puppet/util/settings.rb
	spec/integration/defaults.rb
	spec/unit/node/catalog.rb
	spec/unit/type/interface.rb
	spec/unit/type/ssh_authorized_key.rb

13 files changed, 360 insertions, 615 deletions

diff --git a/spec/integration/defaults.rb b/spec/integration/defaults.rb
index 9d8ea30f7..eba58a3d5 100755
--- a/spec/integration/defaults.rb
+++ b/spec/integration/defaults.rb
@@ -27,4 +27,24 @@ describe "Puppet defaults" do
             Puppet.settings[:cacrl] = 'false'
         end
     end
+
+    it "should have a clientyamldir setting" do
+        Puppet.settings[:clientyamldir].should_not be_nil
+    end
+
+    it "should have different values for the yamldir and clientyamldir" do
+        Puppet.settings[:yamldir].should_not == Puppet.settings[:clientyamldir]
+    end
+
+    # See #1232
+    it "should not specify a user or group for the clientyamldir" do
+        Puppet.settings.element(:clientyamldir).owner.should be_nil
+        Puppet.settings.element(:clientyamldir).group.should be_nil
+    end
+
+    # See #1232
+    it "should not specify a user or group for the rundir" do
+        Puppet.settings.element(:rundir).owner.should be_nil
+        Puppet.settings.element(:rundir).group.should be_nil
+    end
 end
diff --git a/spec/unit/indirector/node/ldap.rb b/spec/unit/indirector/node/ldap.rb
index 01d148631..ed8809e73 100755
--- a/spec/unit/indirector/node/ldap.rb
+++ b/spec/unit/indirector/node/ldap.rb
@@ -136,6 +136,14 @@ describe Puppet::Node::Ldap do
                 @searcher.stubs(:name2hash).returns @result
             end
 
+            it "should create the node with the correct name, even if it was found by a different name" do
+                @searcher.expects(:name2hash).with("mynode.domain.com").returns nil
+                @searcher.expects(:name2hash).with("mynode").returns @result
+
+                Puppet::Node.expects(:new).with("mynode.domain.com").returns @node
+                @searcher.find(@request)
+            end
+
             it "should add any classes from ldap" do
                 @result[:classes] = %w[a b c d]
                 @node.expects(:classes=).with(%w{a b c d})
@@ -161,6 +169,19 @@ describe Puppet::Node::Ldap do
                 @searcher.find(@request)
             end
 
+            it "should merge the node's facts after the parameters from ldap are assigned" do
+                # Make sure we've got data to start with, so the parameters are actually set.
+                @result[:parameters] = {}
+                @result[:parameters]["one"] = "yay"
+
+                # A hackish way to enforce order.
+                set = false
+                @node.expects(:parameters=).with { |*args| set = true }
+                @node.expects(:fact_merge).with { |*args| raise "Facts were merged before parameters were set" unless set; true }
+
+                @searcher.find(@request)
+            end
+
             describe "and a parent node is specified" do
                 before do
                     @entry = {:classes => [], :parameters => {}}
@@ -304,13 +325,22 @@ describe Puppet::Node::Ldap do
             @searcher.search @request
         end
 
-        it "should return a node for each processed entry" do
-            @searcher.expects(:ldapsearch).yields("one")
-            @searcher.expects(:entry2hash).with("one").returns(:name => "foo")
+        it "should return a node for each processed entry with the name from the entry" do
+            @searcher.expects(:ldapsearch).yields("whatever")
+            @searcher.expects(:entry2hash).with("whatever").returns(:name => "foo")
             result = @searcher.search(@request)
             result[0].should be_instance_of(Puppet::Node)
             result[0].name.should == "foo"
         end
+
+        it "should merge each node's facts" do
+            node = mock 'node'
+            Puppet::Node.expects(:new).with("foo").returns node
+            node.expects(:fact_merge)
+            @searcher.stubs(:ldapsearch).yields("one")
+            @searcher.stubs(:entry2hash).with("one").returns(:name => "foo")
+            @searcher.search(@request)
+        end
     end
 end
 
diff --git a/spec/unit/indirector/yaml.rb b/spec/unit/indirector/yaml.rb
index 53d12f426..3875d70aa 100755
--- a/spec/unit/indirector/yaml.rb
+++ b/spec/unit/indirector/yaml.rb
@@ -20,12 +20,25 @@ describe Puppet::Indirector::Yaml, " when choosing file location" do
         @subject.name = :me
 
         @dir = "/what/ever"
-        Puppet.settings.stubs(:value).with(:yamldir).returns(@dir)
+        Puppet.settings.stubs(:value).returns("fakesettingdata")
+        Puppet.settings.stubs(:value).with(:clientyamldir).returns(@dir)
 
         @request = stub 'request', :key => :me, :instance => @subject
     end
 
     describe Puppet::Indirector::Yaml, " when choosing file location" do
+        it "should use the yamldir if the process name is 'puppetmasterd'" do
+            Puppet.settings.expects(:value).with(:name).returns "puppetmasterd"
+            Puppet.settings.expects(:value).with(:yamldir).returns "/main/yaml/dir"
+            @store.path(:me).should =~ %r{^/main/yaml/dir}
+        end
+
+        it "should use the client yamldir if the process name is not 'puppetmasterd'" do
+            Puppet.settings.expects(:value).with(:name).returns "cient"
+            Puppet.settings.expects(:value).with(:clientyamldir).returns "/client/yaml/dir"
+            @store.path(:me).should =~ %r{^/client/yaml/dir}
+        end
+
         it "should store all files in a single file root set in the Puppet defaults" do
             @store.path(:me).should =~ %r{^#{@dir}}
         end
diff --git a/spec/unit/node/catalog.rb b/spec/unit/node/catalog.rb
index 42a156286..c986fc24e 100755
--- a/spec/unit/node/catalog.rb
+++ b/spec/unit/node/catalog.rb
@@ -492,7 +492,12 @@ describe Puppet::Node::Catalog, " when functioning as a resource container" do
         @catalog.resource("me", "other").should equal(@one)
     end
 
-    it "should fail to add an alias if the aliased name already exists as a resource" do
+    it "should ignore conflicting aliases that point to the aliased resource" do
+        @catalog.alias(@one, "other")
+        lambda { @catalog.alias(@one, "other") }.should_not raise_error
+    end
+
+    it "should fail to add an alias if the aliased name already exists" do
         @catalog.add_resource @one
         proc { @catalog.alias @two, "one" }.should raise_error(ArgumentError)
     end
diff --git a/spec/unit/other/pgraph.rb b/spec/unit/other/pgraph.rb
index 10ab934a6..cad0832a5 100755
--- a/spec/unit/other/pgraph.rb
+++ b/spec/unit/other/pgraph.rb
@@ -47,8 +47,8 @@ end
 describe Puppet::PGraph, " when matching edges" do
     before do
         @graph = Puppet::PGraph.new
-	    @event = Puppet::Event.new(:source => "a", :event => :yay)
-	    @none = Puppet::Event.new(:source => "a", :event => :NONE)
+	    @event = Puppet::Transaction::Event.new(:yay, "a")
+	    @none = Puppet::Transaction::Event.new(:NONE, "a")
 
 	    @edges = {}
 	    @edges["a/b"] = Puppet::Relationship.new("a", "b", {:event => :yay, :callback => :refresh})
diff --git a/spec/unit/provider/interface/redhat.rb b/spec/unit/provider/interface/redhat.rb
deleted file mode 100755
index 99ac50f01..000000000
--- a/spec/unit/provider/interface/redhat.rb
+++ /dev/null
@@ -1,268 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-11-20.
-#  Copyright (c) 2006. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-provider_class = Puppet::Type.type(:interface).provider(:redhat)
-
-describe provider_class do
-    it "should not be functional on systems without a network-scripts directory" do
-        FileTest.expects(:exist?).with("/etc/sysconfig/network-scripts").returns(false)
-        provider_class.should_not be_suitable
-    end
-
-    it "should be functional on systems with a network-scripts directory" do
-        FileTest.expects(:exist?).with("/etc/sysconfig/network-scripts").returns(true)
-        provider_class.should be_suitable
-    end
-end
-
-describe provider_class, " when determining the file path" do
-    it "should always contain '/etc/sysconfig/network-scripts/ifcfg-'" do
-        provider = provider_class.new(:name => "192.168.0.1")
-        provider.file_path.should =~ %r{^/etc/sysconfig/network-scripts/ifcfg-}
-    end
-
-    it "should include the interface name and the description when the interface is an alias" do
-        provider = provider_class.new(:name => "192.168.0.1", :interface => "eth0")
-        provider.interface_type = :alias
-        resource = stub 'resource'
-        resource.stubs(:[]).with(:interface_desc).returns("blah")
-        provider.resource = resource
-        provider.file_path.should == "/etc/sysconfig/network-scripts/ifcfg-eth0:blah"
-    end
-
-    it "should just include the description when the interface is not an alias" do
-        provider = provider_class.new(:name => "192.168.0.1")
-        provider.interface_type = :normal
-        resource = stub 'resource'
-        resource.stubs(:[]).with(:interface_desc).returns("eth0")
-        provider.resource = resource
-        provider.file_path.should == "/etc/sysconfig/network-scripts/ifcfg-eth0"
-    end
-
-    it "should use the interface description if one is available" do
-        provider = provider_class.new(:name => "192.168.0.1")
-        provider.interface_type = :normal
-        resource = stub 'resource'
-        resource.stubs(:[]).with(:interface_desc).returns("eth0")
-        provider.resource = resource
-        provider.file_path.should == "/etc/sysconfig/network-scripts/ifcfg-eth0"
-    end
-
-    it "should use the name if no interface description is available" do
-        provider = provider_class.new(:name => "192.168.0.1")
-        provider.interface_type = :normal
-        provider.file_path.should == "/etc/sysconfig/network-scripts/ifcfg-192.168.0.1"
-    end
-
-    it "should fail if no name or interface description can be found" do
-        provider = provider_class.new()
-        proc { provider.file_path }.should raise_error
-    end
-end
-
-describe provider_class, " when returning instances" do
-    it "should consider each file in the network-scripts directory an interface instance" do
-        Dir.expects(:glob).with("/etc/sysconfig/network-scripts/ifcfg-*").returns(%w{one two})
-        one = {:name => "one"}
-        two = {:name => "two"}
-        Puppet::Type::Interface::ProviderRedhat.expects(:parse).with("one").returns(one)
-        Puppet::Type::Interface::ProviderRedhat.expects(:parse).with("two").returns(two)
-        Puppet::Type::Interface::ProviderRedhat.expects(:new).with(one).returns(:one)
-        Puppet::Type::Interface::ProviderRedhat.expects(:new).with(two).returns(:two)
-        Puppet::Type::Interface::ProviderRedhat.instances.should == [:one, :two]
-    end
-end
-
-describe provider_class, " when parsing" do
-    it "should return an unmodified provider if the file does not exist" do
-        FileTest.expects(:exist?).with("/my/file").returns(false)
-        provider = mock 'provider'
-        Puppet::Type::Interface::ProviderRedhat.expects(:new).returns(provider)
-        Puppet::Type::Interface::ProviderRedhat.parse("/my/file").should equal(provider)
-    end
-
-    it "should set each attribute in the file on the provider" do
-        FileTest.expects(:exist?).with("/my/file").returns(true)
-        File.expects(:readlines).with("/my/file").returns(%w{one=two three=four})
-        provider = mock 'provider'
-        Puppet::Type::Interface::ProviderRedhat.expects(:new).returns(provider)
-        provider.expects(:one=).with('two')
-        provider.expects(:three=).with('four')
-        Puppet::Type::Interface::ProviderRedhat.parse("/my/file").should equal(provider)
-    end
-end
-
-describe provider_class, " when setting the device to a value containing ':'" do
-    before do
-        @provider = Puppet::Type::Interface::ProviderRedhat.new
-        @provider.device = "one:two"
-    end
-    it "should set the interface type to :alias" do
-        @provider.interface_type.should == :alias
-    end
-    it "should set the interface to the string to the left of the ':'" do
-        @provider.interface.should == "one"
-    end
-    it "should set the ifnum to the string to the right of the ':'" do
-        @provider.ifnum.should == "two"
-    end
-end
-
-describe provider_class, " when setting the device to a value starting with 'dummy-'" do
-    before do
-        @provider = Puppet::Type::Interface::ProviderRedhat.new
-        @provider.device = "dummy5"
-    end
-    it "should set the interface type to :loopback" do
-        @provider.interface_type.should == :loopback
-    end
-    it "should set the interface to 'dummy'" do
-        @provider.interface.should == "dummy"
-    end
-    it "should set the ifnum to remainder of value after removing 'dummy'" do
-        @provider.ifnum.should == "5"
-    end
-end
-
-describe provider_class, " when setting the device to a value containing neither 'dummy-' nor ':'" do
-    before do
-        @provider = Puppet::Type::Interface::ProviderRedhat.new
-        @provider.device = "whatever"
-    end
-    it "should set the interface type to :normal" do
-        @provider.interface_type.should == :normal
-    end
-    it "should set the interface to the device value" do
-        @provider.interface.should == "whatever"
-    end
-end
-
-describe provider_class, " when setting the on_boot value" do
-    before do
-        @provider = Puppet::Type::Interface::ProviderRedhat.new
-    end
-    it "should set it to :true if the value is 'yes'" do
-        @provider.on_boot = "yes"
-        @provider.onboot.should == :true
-    end
-    it "should set it to :false if the value is not 'yes'" do
-        @provider.on_boot = "no"
-        @provider.onboot.should == :false
-    end
-end
-
-describe provider_class, " when setting the ipaddr value" do
-    before do
-        @provider = Puppet::Type::Interface::ProviderRedhat.new
-    end
-
-    it "should set the name to the provided value" do
-        @provider.ipaddr = "yay"
-        @provider.name.should == "yay"
-    end
-end
-
-describe provider_class, " when generating" do
-    before do
-        @provider = Puppet::Type::Interface::ProviderRedhat.new
-        @provider.interface_type = :alias
-        @provider.stubs(:device).returns("mydevice")
-        @provider.stubs(:on_boot).returns("myboot")
-        @provider.stubs(:name).returns("myname")
-        @provider.stubs(:netmask).returns("mynetmask")
-        @provider.interface_type = :alias
-
-        @text = @provider.generate
-    end
-
-    it "should set the bootproto to none if the interface is an alias" do
-        @text.should =~ /^BOOTPROTO=none$/
-    end
-
-    it "should set the bootproto to static if the interface is a loopback" do
-        @provider.interface_type = :loopback
-        @text = @provider.generate
-        @text.should =~ /^BOOTPROTO=static$/
-    end
-
-    it "should set the broadcast address to nothing" do
-        @text.should =~ /^BROADCAST=$/
-    end
-
-    it "should set the netmask to mynetmask" do
-        @text.should =~ /^NETMASK=mynetmask$/
-    end
-
-    it "should set the device to the provider's device" do
-        @text.should =~ /^DEVICE=mydevice$/
-    end
-
-    it "should set the onboot to the provider's on_boot value" do
-        @text.should =~ /^ONBOOT=myboot$/
-    end
-
-    it "should set the ipaddr to the provider's name" do
-        @text.should =~ /^IPADDR=myname$/
-    end
-end
-
-describe provider_class, " when creating and destroying" do
-    before do
-        @provider = provider_class.new(:interface => "eth0", :name => "testing")
-        @path = "/etc/sysconfig/network-scripts/ifcfg-testing"
-    end
-
-    it "should consider the interface present if the file exists" do
-        FileTest.expects(:exist?).with(@path).returns(true)
-        @provider.should be_exists
-    end
-
-    it "should consider the interface absent if the file does not exist" do
-        FileTest.expects(:exist?).with(@path).returns(false)
-        @provider.should_not be_exists
-    end
-
-    it "should remove the file if the interface is being destroyed" do
-        File.expects(:unlink).with(@path)
-        @provider.destroy
-    end
-
-    it "should mark :ensure as :absent if the interface is destroyed" do
-        File.stubs(:unlink)
-        @provider.destroy
-        @provider.ensure.should == :absent
-    end
-
-    it "should mark :ensure as :present if the interface is being created" do
-        resource = stub 'resource', :name => 'testing'
-        resource.stubs(:should).with { |name| name == :ensure }.returns(:present)
-        resource.stubs(:should).with { |name| name != :ensure }.returns(nil)
-        @provider.resource = resource
-        @provider.create
-        @provider.ensure.should == :present
-    end
-
-    it "should write the generated text to disk when the interface is flushed" do
-        fh = mock("filehandle")
-        File.expects(:open).yields(fh)
-        fh.expects(:puts).with("generated")
-        resource = stub 'resource', :name => 'testing'
-        resource.stubs(:[]).with(:interface_desc).returns(nil)
-        resource.stubs(:should).with { |name| name == :ensure }.returns(:present)
-        resource.stubs(:should).with { |name| name != :ensure }.returns(nil)
-        @provider.resource = resource
-        @provider.create
-
-        @provider.stubs(:generate).returns("generated")
-        @provider.flush
-    end
-
-    it "should not write the generated text to disk when the interface is flushed if :ensure == :absent" do
-        @provider.ensure = :absent
-        @provider.flush
-    end
-end
diff --git a/spec/unit/provider/interface/sunos.rb b/spec/unit/provider/interface/sunos.rb
deleted file mode 100755
index 6a7bd19c1..000000000
--- a/spec/unit/provider/interface/sunos.rb
+++ /dev/null
@@ -1,239 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-11-25.
-#  Copyright (c) 2006. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppet/provider/interface/sunos'
-
-
-provider_class = Puppet::Type.type(:interface).provider(:sunos)
-
-describe provider_class do
-    it "should not be functional on non-SunOS kernels" do
-        Facter.expects(:value).with(:kernel).returns("Linux")
-        provider_class.should_not be_suitable
-    end
-
-    it "should be functional on SunOS kernels" do
-        Facter.expects(:value).with(:kernel).returns("SunOS")
-        provider_class.should be_suitable
-    end
-
-    it "should pick its file path by combining '/etc/hostname.' with the interface if one is set" do
-        provider = provider_class.new(:record_type => :sunos, :interface_type => :normal, :name => "testing", :interface => 'eth0')
-        provider.file_path.should == "/etc/hostname.eth0"
-    end
-
-    it "should pick its file path by combining '/etc/hostname.' with the resource's interface if one is not set in the provider" do
-        provider = provider_class.new(:record_type => :sunos, :interface_type => :normal, :name => "testing")
-        resource = mock 'resource'
-        resource.stubs(:[]).with(:interface).returns("eth0")
-        provider.resource = resource
-        provider.file_path.should == "/etc/hostname.eth0"
-    end
-
-    it "should fail when picking its file path if there is no resource nor an interface set in the provider" do
-        provider = provider_class.new(:record_type => :sunos, :interface_type => :normal, :name => "testing")
-        proc { provider.file_path }.should raise_error(Puppet::Error)
-    end
-end
-
-describe provider_class, " when listing interfaces" do
-    it "should return an instance for every file matching /etc/hostname.*, created with the interface name set from the file" do
-        Dir.expects(:glob).with("/etc/hostname.*").returns(%w{/etc/hostname.one /etc/hostname.two})
-        one_instance = stub 'one_instance', :parse => nil
-        two_instance = stub 'two_instance', :parse => nil
-        provider_class.expects(:new).with(:interface => "one").returns(one_instance)
-        provider_class.expects(:new).with(:interface => "two").returns(two_instance)
-
-        provider_class.instances.should == [one_instance, two_instance]
-    end
-
-    it "should call parse on each instance being returned" do
-        Dir.expects(:glob).with("/etc/hostname.*").returns(%w{/etc/hostname.one})
-        one_instance = mock 'one_instance'
-        provider_class.expects(:new).with(:interface => "one").returns(one_instance)
-
-        one_instance.expects(:parse)
-
-        provider_class.instances
-    end
-
-    it "should assign matching providers to any prefetched instances" do
-        Dir.expects(:glob).with("/etc/hostname.*").returns(%w{one two})
-        one_instance = stub 'one_instance', :name => "one", :parse => nil
-        two_instance = stub 'two_instance', :name => "two", :parse => nil
-        provider_class.expects(:new).with(:interface => "one").returns(one_instance)
-        provider_class.expects(:new).with(:interface => "two").returns(two_instance)
-
-        resources = {"one" => mock("one"), "three" => mock('three')}
-        resources["one"].expects(:provider=).with(one_instance)
-
-        provider_class.prefetch(resources)
-    end
-end
-
-describe provider_class, " when creating and destroying" do
-    before do
-        @provider = provider_class.new(:interface => "eth0", :name => "testing")
-    end
-
-    it "should consider the interface present if the file exists" do
-        FileTest.expects(:exist?).with("/etc/hostname.eth0").returns(true)
-        @provider.should be_exists
-    end
-
-    it "should consider the interface absent if the file does not exist" do
-        FileTest.expects(:exist?).with("/etc/hostname.eth0").returns(false)
-        @provider.should_not be_exists
-    end
-
-    it "should remove the file if the interface is being destroyed" do
-        File.expects(:unlink).with("/etc/hostname.eth0")
-        @provider.destroy
-    end
-
-    it "should mark :ensure as :absent if the interface is destroyed" do
-        File.stubs(:unlink)
-        @provider.destroy
-        @provider.ensure.should == :absent
-    end
-
-    it "should mark :ensure as :present if the interface is being created" do
-        resource = stub 'resource', :name => 'testing'
-        resource.stubs(:should).with { |name| name == :ensure }.returns(:present)
-        resource.stubs(:should).with { |name| name != :ensure }.returns(nil)
-        @provider.resource = resource
-        @provider.create
-        @provider.ensure.should == :present
-    end
-
-    it "should write the generated text to disk when the interface is flushed" do
-        fh = mock("filehandle")
-        File.expects(:open).yields(fh)
-        fh.expects(:print).with("testing\n")
-        resource = stub 'resource', :name => 'testing'
-        resource.stubs(:should).with { |name| name == :ensure }.returns(:present)
-        resource.stubs(:should).with { |name| name != :ensure }.returns(nil)
-        @provider.resource = resource
-        @provider.create
-        @provider.flush
-    end
-
-    it "should not write the generated text to disk when the interface is flushed if :ensure == :absent" do
-        @provider.ensure = :absent
-        @provider.flush
-    end
-end
-
-describe provider_class, " when parsing a non-existant file" do
-    it "should mark the interface as absent" do
-        @provider = provider_class.new(:interface => "eth0", :name => "testing")
-        FileTest.expects(:exist?).with("/etc/hostname.eth0").returns(false)
-        @provider.parse
-        @provider.ensure.should == :absent
-    end
-end
-
-describe provider_class, " when parsing an existing file" do
-    before do
-        @provider = provider_class.new(:interface => "eth0", :name => "testing")
-        FileTest.stubs(:exist?).with("/etc/hostname.eth0").returns(true)
-    end
-
-    def set_text(text)
-        File.stubs(:read).with("/etc/hostname.eth0").returns(text)
-    end
-
-    it "should retain the interface name" do
-        set_text "testing"
-        @provider.parse
-        @provider.ensure.should == :present
-        @provider.interface.should == "eth0"
-    end
-
-    it "should mark the interface as present" do
-        set_text "testing"
-        @provider.parse
-        @provider.ensure.should == :present
-    end
-
-    it "should mark the interface as an alias if the first word is 'addif'" do
-        set_text "addif testing"
-        @provider.parse
-        @provider.interface_type.should == :alias
-    end
-
-    it "should not mark the interface as normal if the first word is not 'addif'" do
-        set_text "testing"
-        @provider.parse
-        @provider.interface_type.should == :normal
-    end
-
-    it "should start the interface on boot of the last word is 'up'" do
-        set_text "testing up"
-        @provider.parse
-        @provider.onboot.should == :true
-    end
-
-    it "should not start the interface on boot of the last word is not 'up'" do
-        set_text "testing"
-        @provider.parse
-        @provider.onboot.should == :false
-    end
-
-    it "should set the interface to the first non-behavioural word" do
-        set_text "addif testing up"
-        @provider.parse
-        @provider.name.should == "testing"
-    end
-
-    it "should consider any remaining terms to be interface options" do
-        set_text "addif testing -O up"
-        @provider.parse
-        @provider.ifopts.should == "-O"
-    end
-end
-
-describe provider_class, " when generating" do
-    before do
-        @provider = provider_class.new(:interface => "eth0", :name => "testing")
-    end
-
-    it "should prefix the text with 'addif' if the interface is an alias" do
-        @provider.interface_type = :alias
-        @provider.generate.should == "addif testing"
-    end
-
-    it "should not prefix the text with 'addif' if the interface is not an alias" do
-        @provider.generate.should == "testing"
-    end
-
-    it "should put the ifopts after the name if they are present" do
-        @provider.ifopts = "-O"
-        @provider.generate.should == "testing -O"
-    end
-
-    it "should mark the interface up if onboot is enabled" do
-        @provider.onboot = :true
-        @provider.generate.should == "testing up"
-    end
-
-    it "should use the resource name if no provider name is present" do
-        provider = provider_class.new(:interface => "eth0")
-        resource = stub 'resource', :name => "rtest"
-        provider.resource = resource
-        provider.generate.should == "rtest"
-    end
-
-    it "should use the provider name if present" do
-        @provider.generate.should == "testing"
-    end
-
-    it "should fail if neither a resource nor the provider name is present" do
-        provider = provider_class.new(:interface => "eth0")
-        proc { provider.generate }.should raise_error
-    end
-end
diff --git a/spec/unit/transaction/change.rb b/spec/unit/transaction/change.rb
new file mode 100755
index 000000000..eaa6fb4ab
--- /dev/null
+++ b/spec/unit/transaction/change.rb
@@ -0,0 +1,182 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transaction/change'
+
+describe Puppet::Transaction::Change do
+    Change = Puppet::Transaction::Change
+
+    describe "when initializing" do
+        before do
+            @property = stub 'property', :path => "/property/path", :should => "shouldval"
+        end
+
+        it "should require the property and current value" do
+            lambda { Change.new() }.should raise_error
+        end
+
+        it "should set its property to the provided property" do
+            Change.new(@property, "value").property.should == :property
+        end
+
+        it "should set its 'is' value to the provided value" do
+            Change.new(@property, "value").is.should == "value"
+        end
+
+        it "should retrieve the 'should' value from the property" do
+            # Yay rspec :)
+            Change.new(@property, "value").should.should == @property.should
+        end
+
+        it "should set its path to the path of the property plus 'change'" do
+            Change.new(@property, "value").path.should == [@property.path, "change"]
+        end
+    end
+
+    describe "when an instance" do
+        before do
+            @property = stub 'property', :path => "/property/path", :should => "shouldval"
+            @change = Change.new(@property, "value")
+        end
+
+        it "should be noop if the property is noop" do
+            @property.expects(:noop).returns true
+            @change.noop?.should be_true
+        end
+
+        it "should set its resource to the proxy if it has one" do
+            @change.proxy = :myresource
+            @change.resource.should == :myresource
+        end
+
+        it "should set its resource to the property's resource if no proxy is set" do
+            @property.expects(:resource).returns :myresource
+            @change.resource.should == :myresource
+        end
+
+        it "should have a method for marking that it's been execution" do
+            @change.changed = true
+            @change.changed?.should be_true
+        end
+
+        describe "and creating an event" do
+            before do
+                @property.stubs(:resource).returns "myresource"
+            end
+
+            it "should produce a warning if the event name is not a symbol" do
+                @property.expects(:warning)
+                @property.stubs(:event).returns :myevent
+                @change.event("a string")
+            end
+
+            it "should use the property to generate the event name if the provided name is not a symbol" do
+                @property.stubs(:warning)
+                @property.expects(:event).with(@change.should).returns :myevent
+
+                Puppet::Transaction::Event.expects(:new).with { |name, source| name == :myevent }
+
+                @change.event("a string")
+            end
+        end
+
+        describe "and executing" do
+            describe "in noop mode" do
+                before { @change.stubs(:noop?).returns true }
+
+                it "should log that it is in noop" do
+                    @property.expects(:is_to_s)
+                    @property.expects(:should_to_s)
+                    @property.expects(:log)
+
+                    @change.stubs :event
+                    @change.forward
+                end
+                
+                it "should produce a :noop event and return" do
+                    @property.stub_everything
+
+                    @change.expects(:event).with(:noop).returns :noop_event
+
+                    @change.forward.should == [:noop_event]
+                end
+            end
+
+            describe "without noop" do
+                before do
+                    @change.stubs(:noop?).returns false
+                    @property.stub_everything
+                    @property.stubs(:resource).returns "myresource"
+                end
+
+                it "should sync the property" do
+                    @property.expects(:sync)
+
+                    @change.forward
+                end
+
+                it "should return nil if syncing the property returns nil" do
+                    @property.stubs(:sync).returns nil
+
+                    @change.forward.should be_nil
+                end
+
+                it "should return nil if syncing the property returns an empty array" do
+                    @property.stubs(:sync).returns []
+
+                    @change.forward.should be_nil
+                end
+
+                it "should log the change" do
+                    @property.expects(:sync).returns [:one]
+
+                    @property.expects(:log)
+                    @property.expects(:change_to_s)
+
+                    @change.forward
+                end
+
+                it "should return an array of events" do
+                    @property.expects(:sync).returns [:one, :two]
+
+                    @change.expects(:event).with(:one).returns :uno
+                    @change.expects(:event).with(:two).returns :dos
+
+                    @change.forward.should == [:uno, :dos]
+                end
+            end
+
+            describe "backward" do
+                before do
+                    @property = stub 'property'
+                    @property.stub_everything
+                    @property.stubs(:should).returns "shouldval"
+                    @change = Change.new(@property, "value")
+                    @change.stubs :go
+                end
+
+                it "should swap the 'is' and 'should' values" do
+                    @change.backward
+                    @change.is.should == "shouldval"
+                    @change.should.should == "value"
+                end
+
+                it "should set the 'should' value on the property to the previous 'is' value" do
+                    @property.expects(:should=).with "value"
+                    @change.backward
+                end
+
+                it "should log that it's reversing the change" do
+                    @property.expects(:info)
+                    @change.backward
+                end
+
+                it "should execute" do
+                    @change.expects(:go)
+                    @change.backward
+                end
+            end
+        end
+    end
+end
diff --git a/spec/unit/transaction/event.rb b/spec/unit/transaction/event.rb
new file mode 100755
index 000000000..9fd71aae1
--- /dev/null
+++ b/spec/unit/transaction/event.rb
@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transaction/event'
+
+describe Puppet::Transaction::Event do
+    Event = Puppet::Transaction::Event
+
+    it "should require a name and a source" do
+        lambda { Event.new }.should raise_error(ArgumentError)
+    end
+
+    it "should have a name getter" do
+        Event.new(:foo, "bar").name.should == :foo
+    end
+
+    it "should have a source accessor" do
+        Event.new(:foo, "bar").source.should == "bar"
+    end
+
+    it "should be able to produce a string containing the event name and the source" do
+        Event.new(:event, :source).to_s.should == "source -> event"
+    end
+end
diff --git a/spec/unit/type/file.rb b/spec/unit/type/file.rb
index d6add8609..128e14a01 100755
--- a/spec/unit/type/file.rb
+++ b/spec/unit/type/file.rb
@@ -31,6 +31,18 @@ describe Puppet::Type.type(:file) do
         end
     end
 
+    describe "when specifying a source" do
+        before do
+            @file[:source] = "/bar"
+        end
+
+        it "should raise if source doesn't exist" do
+            @file.property(:source).expects(:found?).returns(false)
+            lambda { @file.retrieve }.should raise_error(Puppet::Error)
+        end
+
+    end
+
     describe "when retrieving remote files" do
         before do
             @filesource = Puppet::Type::File::FileSource.new
diff --git a/spec/unit/type/interface.rb b/spec/unit/type/interface.rb
deleted file mode 100755
index 4e27e35ea..000000000
--- a/spec/unit/type/interface.rb
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-interface = Puppet::Type.type(:interface)
-
-describe interface do
-    before do
-        @class = Puppet::Type.type(:interface)
-
-        @provider_class = stub 'provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true
-        @class.stubs(:defaultprovider).returns(@provider_class)
-        @class.stubs(:provider).returns(@provider_class)
-
-        @provider = stub 'provider', :class => @provider_class, :file_path => "/tmp/whatever", :clear => nil
-        @provider_class.stubs(:new).returns(@provider)
-    end
-
-    it "should have a name parameter" do
-        @class.attrtype(:name).should == :param
-    end
-
-    it "should have :name be its namevar" do
-        @class.namevar.should == :name
-    end
-
-    it "should have a :provider parameter" do
-        @class.attrtype(:provider).should == :param
-    end
-
-    it "should have an ensure property" do
-        @class.attrtype(:ensure).should == :property
-    end
-
-    it "should support :present as a value for :ensure" do
-        proc { @class.create(:name => "whev", :ensure => :present) }.should_not raise_error
-    end
-
-    it "should support :absent as a value for :ensure" do
-        proc { @class.create(:name => "whev", :ensure => :absent) }.should_not raise_error
-    end
-
-    it "should have an interface_type property" do
-        @class.attrtype(:interface_type).should == :property
-    end
-    it "should support :loopback as an interface_type value" do
-        proc { @class.create(:name => "whev", :interface_type => :loopback) }.should_not raise_error
-    end
-    it "should support :alias as an interface_type value" do
-        proc { @class.create(:name => "whev", :interface_type => :alias) }.should_not raise_error
-    end
-    it "should support :normal as an interface_type value" do
-        proc { @class.create(:name => "whev", :interface_type => :normal) }.should_not raise_error
-    end
-    it "should alias :dummy to the :loopback interface_type value" do
-        int = @class.create(:name => "whev", :interface_type => :dummy)
-        int.should(:interface_type).should == :loopback
-    end
-
-    it "should not support values other than :loopback, :alias, :normal, and :dummy in the interface_type" do
-        proc { @class.create(:name => "whev", :interface_type => :something) }.should raise_error(Puppet::Error)
-    end
-
-    it "should have an interface_desc parameter" do
-        @class.attrtype(:interface_desc).should == :param
-    end
-
-    it "should have an onboot property" do
-        @class.attrtype(:onboot).should == :property
-    end
-    it "should support :true as an onboot value" do
-        proc { @class.create(:name => "whev", :onboot => :true) }.should_not raise_error
-    end
-    it "should support :false as an onboot value" do
-        proc { @class.create(:name => "whev", :onboot => :false) }.should_not raise_error
-    end
-
-    it "should have an ifnum property" do
-        @class.attrtype(:ifnum).should == :property
-    end
-
-    it "should have a netmask property" do
-        @class.attrtype(:netmask).should == :property
-    end
-
-    it "should have an ifopts property" do
-        @class.attrtype(:ifopts).should == :property
-    end
-
-    it "should have a target parameter" do
-        @class.attrtype(:target).should == :param
-    end
-end
diff --git a/spec/unit/type/ssh_authorized_key.rb b/spec/unit/type/ssh_authorized_key.rb
index 1bdd86f37..bb38fafce 100755
--- a/spec/unit/type/ssh_authorized_key.rb
+++ b/spec/unit/type/ssh_authorized_key.rb
@@ -14,6 +14,7 @@ describe ssh_authorized_key do
 
         @provider = stub 'provider', :class => @provider_class, :file_path => "/tmp/whatever", :clear => nil
         @provider_class.stubs(:new).returns(@provider)
+        @catalog = Puppet::Node::Catalog.new
     end
 
     it "should have a name parameter" do
@@ -33,27 +34,27 @@ describe ssh_authorized_key do
     end
 
     it "should support :present as a value for :ensure" do
-        proc { @class.create(:name => "whev", :ensure => :present) }.should_not raise_error
+        proc { @class.create(:name => "whev", :ensure => :present, :user => "nobody") }.should_not raise_error
     end
 
     it "should support :absent as a value for :ensure" do
-        proc { @class.create(:name => "whev", :ensure => :absent) }.should_not raise_error
+        proc { @class.create(:name => "whev", :ensure => :absent, :user => "nobody") }.should_not raise_error
     end
 
     it "should have an type property" do
         @class.attrtype(:type).should == :property
     end
     it "should support ssh-dss as an type value" do
-        proc { @class.create(:name => "whev", :type => "ssh-dss") }.should_not raise_error
+        proc { @class.create(:name => "whev", :type => "ssh-dss", :user => "nobody") }.should_not raise_error
     end
     it "should support ssh-rsa as an type value" do
-        proc { @class.create(:name => "whev", :type => "ssh-rsa") }.should_not raise_error
+        proc { @class.create(:name => "whev", :type => "ssh-rsa", :user => "nobody") }.should_not raise_error
     end
     it "should support :dsa as an type value" do
-        proc { @class.create(:name => "whev", :type => :dsa) }.should_not raise_error
+        proc { @class.create(:name => "whev", :type => :dsa, :user => "nobody") }.should_not raise_error
     end
     it "should support :rsa as an type value" do
-        proc { @class.create(:name => "whev", :type => :rsa) }.should_not raise_error
+        proc { @class.create(:name => "whev", :type => :rsa, :user => "nobody") }.should_not raise_error
     end
 
     it "should not support values other than ssh-dss, ssh-rsa, dsa, rsa in the ssh_authorized_key_type" do
@@ -75,4 +76,55 @@ describe ssh_authorized_key do
     it "should have a target property" do
         @class.attrtype(:target).should == :property
     end
+
+    it "should autorequire parent directories when user is given" do
+        @catalog.add_resource @class.create(
+          :name   => "Test",
+          :key    => "AAA",
+          :type   => "ssh-rsa",
+          :ensure => :present,
+          :user   => "root")
+        @catalog.apply
+
+        target = File.expand_path("~root/.ssh")
+        @catalog.resource(:file, target).should be_an_instance_of(Puppet::Type.type(:file))
+    end
+
+    it "should set target when user is given" do
+        @catalog.add_resource @class.create(
+          :name   => "Test",
+          :key    => "AAA",
+          :type   => "ssh-rsa",
+          :ensure => :present,
+          :user   => "root")
+        @catalog.apply
+
+        target = File.expand_path("~root/.ssh/authorized_keys")
+        @catalog.resource(:file, target).should be_an_instance_of(Puppet::Type.type(:file))
+    end
+
+
+    it "should autorequire parent directories when target is given" do
+        target = "/tmp/home/foo/bar/.ssh/authorized_keys"
+
+        @catalog.add_resource @class.create(
+          :name   => "Test",
+          :key    => "AAA",
+          :type   => "ssh-rsa",
+          :ensure => :present,
+          :target => target)
+        @catalog.apply
+
+        @catalog.resource(:file, target).should be_an_instance_of(Puppet::Type.type(:file))
+    end
+
+    it "should raise an error when neither user nor target is given" do
+        proc do
+            @class.create(
+              :name   => "Test",
+              :key    => "AAA",
+              :type   => "ssh-rsa",
+              :ensure => :present)
+        end.should raise_error(Puppet::Error)
+    end
 end
diff --git a/spec/unit/util/settings.rb b/spec/unit/util/settings.rb
index f9f77b054..0faa92c68 100755
--- a/spec/unit/util/settings.rb
+++ b/spec/unit/util/settings.rb
@@ -668,11 +668,17 @@ describe Puppet::Util::Settings do
             @settings.reuse
         end
 
-        it "should fail if any resources fail" do
+        it "should fail with an appropriate message if any resources fail" do
             stub_transaction
             @trans.expects(:any_failed?).returns(true)
+            report = mock 'report'
+            @trans.expects(:report).returns report
 
-            proc { @settings.use(:whatever) }.should raise_error(RuntimeError)
+            log = mock 'log', :to_s => "My failure", :level => :err
+            report.expects(:logs).returns [log]
+
+            @settings.expects(:raise).with { |msg| msg.include?("My failure") }
+            @settings.use(:whatever)
         end
     end