diff --git a/spec/integration/checksum.rb b/spec/integration/checksum.rb
index c94f3e47e..49ae8d2b7 100755
--- a/spec/integration/checksum.rb
+++ b/spec/integration/checksum.rb
@@ -1,47 +1,48 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-9-22.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/checksum'
 
 describe Puppet::Checksum, " when using the file terminus" do
     before do
+        Puppet.settings.stubs(:use)
         Puppet::Checksum.terminus_class = :file
         @content = "this is some content"
         @sum = Puppet::Checksum.new(@content)
 
         @file = Puppet::Checksum.indirection.terminus.path(@sum.checksum)
     end
 
     it "should store content at a path determined by its checksum" do
         File.stubs(:directory?).returns(true)
         filehandle = mock 'filehandle'
         filehandle.expects(:print).with(@content)
         File.expects(:open).with(@file, "w").yields(filehandle)
 
         @sum.save
     end
 
     it "should retrieve stored content when the checksum is provided as the key" do
         File.stubs(:exist?).returns(true)
         File.expects(:read).with(@file).returns(@content)
 
         newsum = Puppet::Checksum.find(@sum.checksum)
 
         newsum.content.should == @content
     end
 
     it "should remove specified files when asked" do
         File.stubs(:exist?).returns(true)
         File.expects(:unlink).with(@file)
 
         Puppet::Checksum.destroy(@sum.name)
     end
 
     after do
         Puppet.settings.clear
     end
 end
diff --git a/spec/integration/reports.rb b/spec/integration/reports.rb
index 7351c3da1..cc4ae8f4c 100755
--- a/spec/integration/reports.rb
+++ b/spec/integration/reports.rb
@@ -1,14 +1,18 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-10-12.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/reports'
 
 describe Puppet::Reports, " when using report types" do
+    before do
+        Puppet.settings.stubs(:use)
+    end
+
     it "should load report types as modules" do
         Puppet::Reports.report(:store).should be_instance_of(Module)
     end
 end
diff --git a/spec/integration/transaction/report.rb b/spec/integration/transaction/report.rb
index 48e59f203..333deac0e 100755
--- a/spec/integration/transaction/report.rb
+++ b/spec/integration/transaction/report.rb
@@ -1,26 +1,32 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2008-4-8.
 #  Copyright (c) 2008. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Transaction::Report do
     describe "when using the indirector" do
-        after { Puppet::Transaction::Report.indirection.clear_cache }
+        before do
+            Puppet.settings.stubs(:use)
+        end
+
+        after do
+            Puppet::Transaction::Report.indirection.clear_cache
+        end
 
         it "should be able to delegate to the :processor terminus" do
             Puppet::Transaction::Report.indirection.stubs(:terminus_class).returns :processor
 
             terminus = Puppet::Transaction::Report.indirection.terminus(:processor)
 
             Facter.stubs(:value).returns "host.domain.com"
 
             report = Puppet::Transaction::Report.new
 
             terminus.expects(:process).with(report)
 
             report.save
         end
     end
 end
diff --git a/spec/integration/type/package.rb b/spec/integration/type/package.rb
index def44ad97..a3d8eb278 100755
--- a/spec/integration/type/package.rb
+++ b/spec/integration/type/package.rb
@@ -1,22 +1,25 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:package), "when choosing a default package provider" do
     before do
         # the default provider is cached.
         Puppet::Type.type(:package).defaultprovider = nil
     end
 
     def provider_name(os)
-        {"Debian" => :apt, "Darwin" => :apple, "RedHat" => :up2date, "Fedora" => :yum, "FreeBSD" => :ports, "OpenBSD" => :openbsd, "Solaris" => :sun}[os]
+        {"Ubuntu" => :apt, "Debian" => :apt, "Darwin" => :apple, "RedHat" => :up2date, "Fedora" => :yum, "FreeBSD" => :ports, "OpenBSD" => :openbsd, "Solaris" => :sun}[os]
     end
 
     it "should have a default provider" do
         Puppet::Type.type(:package).defaultprovider.should_not be_nil
     end
 
     it "should choose the correct provider each platform" do
-        Puppet::Type.type(:package).defaultprovider.name.should == provider_name(Facter.value(:operatingsystem))
+        unless default_provider = provider_name(Facter.value(:operatingsystem))
+            pending("No default provider specified in this test for %s" % Facter.value(:operatingsystem))
+        end
+        Puppet::Type.type(:package).defaultprovider.name.should == default_provider
     end
 end
diff --git a/spec/unit/indirector/ssl_rsa/file.rb b/spec/unit/indirector/ssl_rsa/file.rb
index 76e5e3a94..4800f4a71 100755
--- a/spec/unit/indirector/ssl_rsa/file.rb
+++ b/spec/unit/indirector/ssl_rsa/file.rb
@@ -1,116 +1,121 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-9-22.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/sslcertificates/monkey_patch'
 require 'puppet/indirector/ssl_rsa/file'
 
 
 describe Puppet::Indirector::SslRsa::File do
 
     it "should be a subclass of the File terminus class" do
         Puppet::Indirector::SslRsa::File.superclass.should equal(Puppet::Indirector::File)
     end
     
     it "should have documentation" do
         Puppet::Indirector::SslRsa::File.doc.should be_instance_of(String)
     end
 end
 
 describe Puppet::Indirector::SslRsa::File, " when choosing a path for a ca key" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
         @name = :ca
     end
 
     it "should use the cadir" do
         Puppet.settings.stubs(:value).with(:cadir).returns("/dir")
         @file.path(@name).should =~ /^\/dir/
     end
 
     it "should use 'ca_key.pem' as the file name" do
         @file.path(@name).should =~ /ca_key\.pem$/
     end
 end
 
 describe Puppet::Indirector::SslRsa::File, " when choosing a path for a non-ca key" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
         @name = :publickey
     end
 
     it "should use the publickeydir" do
         Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
         @file.path(@name).should =~ /^\/dir/
     end
 
     it "should use the key name with the pem file extension" do
         @file.path(@name).should =~ /#{@name}\.pem$/
     end
 end
 
 describe Puppet::Indirector::SslRsa::File, " when saving" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
 
         Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
         @key = stub "key", :name => "foo"
     end
 
     it "should store the rsa key to disk in pem format" do
         @key.expects(:to_pem).returns(:data)
         @path = "/dir/foo.pem"
         filehandle = mock "filehandle"
         File.expects(:open).with(@path, "w").yields(filehandle)
         filehandle.expects(:print).with(:data)
         @file.save(@key)
     end
 end
 
 describe Puppet::Indirector::SslRsa::File, " when finding a key by name" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
 
         Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
         @name = "foo"
     end
 
     it "should return the key as a key object on success" do
         @path = "/dir/foo.pem"
         FileTest.stubs(:exists?).with(@path).returns(true)
         File.stubs(:read).with(@path).returns(:data)
         OpenSSL::PKey::RSA.expects(:new).with(:data).returns(:mykey)
         @file.find(@name).should == :mykey
     end
 
     it "should return 'nil' on failure" do
         @path = "/dir/foo.pem"
         FileTest.stubs(:exists?).with(@path).returns(false)
         @file.find(@name).should == nil
     end
 end
 
 describe Puppet::Indirector::SslRsa::File, " when removing a key" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
 
         Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
         @name = "foo"
     end
 
     it "should remove the key from disk and return true" do
         @path = "/dir/foo.pem"
         FileTest.stubs(:exists?).with(@path).returns(true)
         File.stubs(:unlink).with(@path).returns(true)
         @file.destroy(@name).should == true
     end
 
     it "should return an exception on failure" do
         @path = "/dir/foo.pem"
         FileTest.stubs(:exists?).with(@path).returns(false)
         @file.destroy(@name).should == nil
     end
 end
diff --git a/spec/unit/node/catalog.rb b/spec/unit/node/catalog.rb
index be198b88e..f6ef291a5 100755
--- a/spec/unit/node/catalog.rb
+++ b/spec/unit/node/catalog.rb
@@ -1,864 +1,865 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Node::Catalog, " when compiling" do
     it "should accept tags" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one")
         config.tags.should == %w{one}
     end
 
     it "should accept multiple tags at once" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one", "two")
         config.tags.should == %w{one two}
     end
 
     it "should convert all tags to strings" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one", :two)
         config.tags.should == %w{one two}
     end
 
     it "should tag with both the qualified name and the split name" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one::two")
         config.tags.include?("one").should be_true
         config.tags.include?("one::two").should be_true
     end
 
     it "should accept classes" do
         config = Puppet::Node::Catalog.new("mynode")
         config.add_class("one")
         config.classes.should == %w{one}
         config.add_class("two", "three")
         config.classes.should == %w{one two three}
     end
 
     it "should tag itself with passed class names" do
         config = Puppet::Node::Catalog.new("mynode")
         config.add_class("one")
         config.tags.should == %w{one}
     end
 end
 
 describe Puppet::Node::Catalog, " when extracting" do
     it "should return extraction result as the method result" do
         config = Puppet::Node::Catalog.new("mynode")
         config.expects(:extraction_format).returns(:whatever)
         config.expects(:extract_to_whatever).returns(:result)
         config.extract.should == :result
     end
 end
 
 describe Puppet::Node::Catalog, " when extracting transobjects" do
 
     def mkscope
         @parser = Puppet::Parser::Parser.new :Code => ""
         @node = Puppet::Node.new("mynode")
         @compiler = Puppet::Parser::Compiler.new(@node, @parser)
 
         # XXX This is ridiculous.
         @compiler.send(:evaluate_main)
         @scope = @compiler.topscope
     end
 
     def mkresource(type, name)
         Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope)
     end
 
     it "should always create a TransBucket for the 'main' class" do
         config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @source = mock 'source'
 
         main = mkresource("class", :main)
         config.add_vertex(main)
 
         bucket = mock 'bucket'
         bucket.expects(:classes=).with(config.classes)
         main.stubs(:builtin?).returns(false)
         main.expects(:to_transbucket).returns(bucket)
 
         config.extract_to_transportable.should equal(bucket)
     end
 
     # This isn't really a spec-style test, but I don't know how better to do it.
     it "should transform the resource graph into a tree of TransBuckets and TransObjects" do
         config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @source = mock 'source'
 
         defined = mkresource("class", :main)
         builtin = mkresource("file", "/yay")
 
         config.add_edge(defined, builtin)
 
         bucket = []
         bucket.expects(:classes=).with(config.classes)
         defined.stubs(:builtin?).returns(false)
         defined.expects(:to_transbucket).returns(bucket)
         builtin.expects(:to_transobject).returns(:builtin)
 
         config.extract_to_transportable.should == [:builtin]
     end
 
     # Now try it with a more complicated graph -- a three tier graph, each tier
     it "should transform arbitrarily deep graphs into isomorphic trees" do
         config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @scope.stubs(:tags).returns([])
         @source = mock 'source'
 
         # Create our scopes.
         top = mkresource "class", :main
         topbucket = []
         topbucket.expects(:classes=).with([])
         top.expects(:to_trans).returns(topbucket)
         topres = mkresource "file", "/top"
         topres.expects(:to_trans).returns(:topres)
         config.add_edge top, topres
 
         middle = mkresource "class", "middle"
         middle.expects(:to_trans).returns([])
         config.add_edge top, middle
         midres = mkresource "file", "/mid"
         midres.expects(:to_trans).returns(:midres)
         config.add_edge middle, midres
 
         bottom = mkresource "class", "bottom"
         bottom.expects(:to_trans).returns([])
         config.add_edge middle, bottom
         botres = mkresource "file", "/bot"
         botres.expects(:to_trans).returns(:botres)
         config.add_edge bottom, botres
 
         toparray = config.extract_to_transportable
 
         # This is annoying; it should look like:
         #   [[[:botres], :midres], :topres]
         # but we can't guarantee sort order.
         toparray.include?(:topres).should be_true
 
         midarray = toparray.find { |t| t.is_a?(Array) }
         midarray.include?(:midres).should be_true
         botarray = midarray.find { |t| t.is_a?(Array) }
         botarray.include?(:botres).should be_true
     end
 end
 
 describe Puppet::Node::Catalog, " when converting to a transobject catalog" do
     class CatalogTestResource
         attr_accessor :name, :virtual, :builtin
         def initialize(name, options = {})
             @name = name
             options.each { |p,v| send(p.to_s + "=", v) }
         end
 
         def ref
             if builtin?
                 "File[%s]" % name
             else
                 "Class[%s]" % name
             end
         end
 
         def virtual?
             virtual
         end
 
         def builtin?
             builtin
         end
 
         def to_transobject
             Puppet::TransObject.new(name, builtin? ? "file" : "class")
         end
     end
 
     before do
         @original = Puppet::Node::Catalog.new("mynode")
         @original.tag(*%w{one two three})
         @original.add_class *%w{four five six}
 
         @top            = CatalogTestResource.new 'top'
         @topobject      = CatalogTestResource.new 'topobject', :builtin => true
         @virtual        = CatalogTestResource.new 'virtual', :virtual => true
         @virtualobject  = CatalogTestResource.new 'virtualobject', :builtin => true, :virtual => true
         @middle         = CatalogTestResource.new 'middle'
         @middleobject   = CatalogTestResource.new 'middleobject', :builtin => true
         @bottom         = CatalogTestResource.new 'bottom'
         @bottomobject   = CatalogTestResource.new 'bottomobject', :builtin => true
 
         @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
         @original.add_edge(@top, @topobject)
         @original.add_edge(@top, @virtual)
         @original.add_edge(@virtual, @virtualobject)
         @original.add_edge(@top, @middle)
         @original.add_edge(@middle, @middleobject)
         @original.add_edge(@middle, @bottom)
         @original.add_edge(@bottom, @bottomobject)
 
         @catalog = @original.to_transportable
     end
 
     it "should add all resources as TransObjects" do
         @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::TransObject) }
     end
 
     it "should not extract defined virtual resources" do
         @catalog.vertices.find { |v| v.name == "virtual" }.should be_nil
     end
 
     it "should not extract builtin virtual resources" do
         @catalog.vertices.find { |v| v.name == "virtualobject" }.should be_nil
     end
 
     it "should copy the tag list to the new catalog" do
         @catalog.tags.sort.should == @original.tags.sort
     end
 
     it "should copy the class list to the new catalog" do
         @catalog.classes.should == @original.classes
     end
 
     it "should duplicate the original edges" do
         @original.edges.each do |edge|
             next if edge.source.virtual? or edge.target.virtual?
             source = @catalog.resource(edge.source.ref)
             target = @catalog.resource(edge.target.ref)
 
             source.should_not be_nil
             target.should_not be_nil
             @catalog.edge?(source, target).should be_true
         end
     end
 
     it "should set itself as the catalog for each converted resource" do
         @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
     end
 end
 
 describe Puppet::Node::Catalog, " when converting to a RAL catalog" do
     before do
         @original = Puppet::Node::Catalog.new("mynode")
         @original.tag(*%w{one two three})
         @original.add_class *%w{four five six}
 
         @top            = Puppet::TransObject.new 'top', "class"
         @topobject      = Puppet::TransObject.new '/topobject', "file"
         @middle         = Puppet::TransObject.new 'middle', "class"
         @middleobject   = Puppet::TransObject.new '/middleobject', "file"
         @bottom         = Puppet::TransObject.new 'bottom', "class"
         @bottomobject   = Puppet::TransObject.new '/bottomobject', "file"
 
         @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
         @original.add_resource(*@resources)
 
         @original.add_edge(@top, @topobject)
         @original.add_edge(@top, @middle)
         @original.add_edge(@middle, @middleobject)
         @original.add_edge(@middle, @bottom)
         @original.add_edge(@bottom, @bottomobject)
 
         @catalog = @original.to_ral
     end
 
     it "should add all resources as RAL instances" do
         @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Type) }
     end
 
     it "should copy the tag list to the new catalog" do
         @catalog.tags.sort.should == @original.tags.sort
     end
 
     it "should copy the class list to the new catalog" do
         @catalog.classes.should == @original.classes
     end
 
     it "should duplicate the original edges" do
         @original.edges.each do |edge|
             @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
         end
     end
 
     it "should set itself as the catalog for each converted resource" do
         @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
     end
 
     it "should convert parser resources to transobjects and set the catalog" do
         catalog = Puppet::Node::Catalog.new("mynode")
 
         result = mock 'catalog'
         result.stub_everything
 
         Puppet::Node::Catalog.expects(:new).returns result
 
         trans = mock 'trans'
         resource = Puppet::Parser::Resource.new(:scope => mock("scope"), :source => mock("source"), :type => :file, :title => "/eh")
         resource.expects(:to_transobject).returns trans
         trans.expects(:catalog=).with result
 
         trans.stub_everything
 
         catalog.add_resource(resource)
 
         catalog.to_ral
     end
 
     # This tests #931.
     it "should not lose track of resources whose names vary" do
         changer = Puppet::TransObject.new 'changer', 'test'
 
         config = Puppet::Node::Catalog.new('test')
         config.add_resource(changer)
         config.add_resource(@top)
 
         config.add_edge(@top, changer)
 
         resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :catalog= => nil, :remove => nil
 
         #changer is going to get duplicated as part of a fix for aliases 1094
         changer.expects(:dup).returns(changer)
         changer.expects(:to_type).returns(resource)
 
         newconfig = nil
 
         Puppet::Type.allclear
 
         proc { @catalog = config.to_ral }.should_not raise_error
         @catalog.resource("Test[changer2]").should equal(resource)
     end
 
     after do
         # Remove all resource instances.
         @catalog.clear(true)
     end
 end
 
 describe Puppet::Node::Catalog, " when functioning as a resource container" do
     before do
         @catalog = Puppet::Node::Catalog.new("host")
         @one = stub 'resource1', :ref => "Me[one]", :catalog= => nil, :title => "one"
         @two = stub 'resource2', :ref => "Me[two]", :catalog= => nil, :title => "two"
         @dupe = stub 'resource3', :ref => "Me[one]", :catalog= => nil, :title => "one"
     end
 
     it "should provide a method to add one or more resources" do
         @catalog.add_resource @one, @two
         @catalog.resource(@one.ref).should equal(@one)
         @catalog.resource(@two.ref).should equal(@two)
     end
 
     it "should set itself as the resource's catalog if it is not a relationship graph" do
         @one.expects(:catalog=).with(@catalog)
         @catalog.add_resource @one
     end
 
     it "should not set itself as the resource's catalog if it is a relationship graph" do
         @one.expects(:catalog=).never
         @catalog.is_relationship_graph = true
         @catalog.add_resource @one
     end
 
     it "should make all vertices available by resource reference" do
         @catalog.add_resource(@one)
         @catalog.resource(@one.ref).should equal(@one)
         @catalog.vertices.find { |r| r.ref == @one.ref }.should equal(@one)
     end
 
     it "should canonize how resources are referred to during retrieval when both type and title are provided" do
         @catalog.add_resource(@one)
 
         @catalog.resource("me", "one").should equal(@one)
     end
 
     it "should canonize how resources are referred to during retrieval when just the title is provided" do
         @catalog.add_resource(@one)
 
         @catalog.resource("me[one]", nil).should equal(@one)
     end
 
     it "should not allow two resources with the same resource reference" do
         @catalog.add_resource(@one)
 
         # These are used to build the failure
         @dupe.stubs(:file)
         @dupe.stubs(:line)
         @one.stubs(:file)
         @one.stubs(:line)
         proc { @catalog.add_resource(@dupe) }.should raise_error(ArgumentError)
     end
 
     it "should not store objects that do not respond to :ref" do
         proc { @catalog.add_resource("thing") }.should raise_error(ArgumentError)
     end
 
     it "should remove all resources when asked" do
         @catalog.add_resource @one
         @catalog.add_resource @two
         @one.expects :remove
         @two.expects :remove
         @catalog.clear(true)
     end
 
     it "should support a mechanism for finishing resources" do
         @one.expects :finish
         @two.expects :finish
         @catalog.add_resource @one
         @catalog.add_resource @two
 
         @catalog.finalize
     end
 
     it "should make default resources when finalizing" do
         @catalog.expects(:make_default_resources)
         @catalog.finalize
     end
 
     it "should add default resources to the catalog upon creation" do
         @catalog.make_default_resources
         @catalog.resource(:schedule, "daily").should_not be_nil
     end
     
     it "should optionally support an initialization block and should finalize after such blocks" do
         @one.expects :finish
         @two.expects :finish
         config = Puppet::Node::Catalog.new("host") do |conf|
             conf.add_resource @one
             conf.add_resource @two
         end
     end
 
     it "should inform the resource that it is the resource's catalog" do
         @one.expects(:catalog=).with(@catalog)
         @catalog.add_resource @one
     end
 
     it "should be able to find resources by reference" do
         @catalog.add_resource @one
         @catalog.resource(@one.ref).should equal(@one)
     end
 
     it "should be able to find resources by reference or by type/title tuple" do
         @catalog.add_resource @one
         @catalog.resource("me", "one").should equal(@one)
     end
 
     it "should have a mechanism for removing resources" do
         @catalog.add_resource @one
         @one.expects :remove
         @catalog.remove_resource(@one)
         @catalog.resource(@one.ref).should be_nil
         @catalog.vertex?(@one).should be_false
     end
 
     it "should have a method for creating aliases for resources" do
         @catalog.add_resource @one
         @catalog.alias(@one, "other")
         @catalog.resource("me", "other").should equal(@one)
     end
 
     # This test is the same as the previous, but the behaviour should be explicit.
     it "should alias using the class name from the resource reference, not the resource class name" do
         @catalog.add_resource @one
         @catalog.alias(@one, "other")
         @catalog.resource("me", "other").should equal(@one)
     end
 
     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
 
     it "should not fail when a resource has duplicate aliases created" do
         @catalog.add_resource @one
         proc { @catalog.alias @one, "one" }.should_not raise_error
     end
 
     it "should not create aliases that point back to the resource" do
         @catalog.alias(@one, "one")
         @catalog.resource(:me, "one").should be_nil
     end
 
     it "should be able to look resources up by their aliases" do
         @catalog.add_resource @one
         @catalog.alias @one, "two"
         @catalog.resource(:me, "two").should equal(@one)
     end
 
     it "should remove resource aliases when the target resource is removed" do
         @catalog.add_resource @one
         @catalog.alias(@one, "other")
         @one.expects :remove
         @catalog.remove_resource(@one)
         @catalog.resource("me", "other").should be_nil
     end
 
     it "should add an alias for the namevar when the title and name differ on isomorphic resource types" do
         resource = Puppet::Type.type(:file).create :path => "/something", :title => "other", :content => "blah"
         resource.expects(:isomorphic?).returns(true)
         @catalog.add_resource(resource)
         @catalog.resource(:file, "other").should equal(resource)
         @catalog.resource(:file, "/something").ref.should == resource.ref
     end
 
     it "should not add an alias for the namevar when the title and name differ on non-isomorphic resource types" do
         resource = Puppet::Type.type(:file).create :path => "/something", :title => "other", :content => "blah"
         resource.expects(:isomorphic?).returns(false)
         @catalog.add_resource(resource)
         @catalog.resource(:file, resource.title).should equal(resource)
         # We can't use .should here, because the resources respond to that method.
         if @catalog.resource(:file, resource.name)
             raise "Aliased non-isomorphic resource"
         end
     end
 
     after do
         Puppet::Type.allclear
     end
 end
 
 describe Puppet::Node::Catalog do
     before :each do
         @catalog = Puppet::Node::Catalog.new("host")
 
         @catalog.retrieval_duration = Time.now
         @transaction = mock 'transaction'
         Puppet::Transaction.stubs(:new).returns(@transaction)
         @transaction.stubs(:evaluate)
         @transaction.stubs(:cleanup)
         @transaction.stubs(:addtimes)
     end
 
     describe Puppet::Node::Catalog, " when applying" do
 
         it "should create and evaluate a transaction" do
             @transaction.expects(:evaluate)
             @catalog.apply
         end
 
         it "should provide the catalog time to the transaction" do
             @transaction.expects(:addtimes).with do |arg|
                 arg[:config_retrieval].should be_instance_of(Time)
                 true
             end
             @catalog.apply
         end
 
         it "should clean up the transaction" do
             @transaction.expects :cleanup
             @catalog.apply
         end
     
         it "should return the transaction" do
             @catalog.apply.should equal(@transaction)
         end
 
         it "should yield the transaction if a block is provided" do
             @catalog.apply do |trans|
                 trans.should equal(@transaction)
             end
         end
     
         it "should default to not being a host catalog" do
             @catalog.host_config.should be_nil
         end
 
         it "should pass supplied tags on to the transaction" do
             @transaction.expects(:tags=).with(%w{one two})
             @catalog.apply(:tags => %w{one two})
         end
 
         it "should set ignoreschedules on the transaction if specified in apply()" do
             @transaction.expects(:ignoreschedules=).with(true)
             @catalog.apply(:ignoreschedules => true)
         end
     end
 
     describe Puppet::Node::Catalog, " when applying host catalogs" do
 
         # super() doesn't work in the setup method for some reason
         before do
             @catalog.host_config = true
             Puppet::Util::Storage.stubs(:store)
         end
 
         it "should send a report if reporting is enabled" do
             Puppet[:report] = true
             @transaction.expects :send_report
             @transaction.stubs :any_failed? => false
             @catalog.apply
         end
 
         it "should send a report if report summaries are enabled" do
             Puppet[:summarize] = true
             @transaction.expects :send_report
             @transaction.stubs :any_failed? => false
             @catalog.apply
         end
 
         it "should initialize the state database before applying a catalog" do
             Puppet::Util::Storage.expects(:load)
 
             # Short-circuit the apply, so we know we're loading before the transaction
             Puppet::Transaction.expects(:new).raises ArgumentError
             proc { @catalog.apply }.should raise_error(ArgumentError)
         end
 
         it "should sync the state database after applying" do
             Puppet::Util::Storage.expects(:store)
             @transaction.stubs :any_failed? => false
             @catalog.apply
         end
 
         after { Puppet.settings.clear }
     end
 
     describe Puppet::Node::Catalog, " when applying non-host catalogs" do
 
         before do
             @catalog.host_config = false
         end
     
         it "should never send reports" do
             Puppet[:report] = true
             Puppet[:summarize] = true
             @transaction.expects(:send_report).never
             @catalog.apply
         end
 
         it "should never modify the state database" do
             Puppet::Util::Storage.expects(:load).never
             Puppet::Util::Storage.expects(:store).never
             @catalog.apply
         end
 
         after { Puppet.settings.clear }
     end
 end
 
 describe Puppet::Node::Catalog, " when creating a relationship graph" do
     before do
         Puppet::Type.type(:component)
         @catalog = Puppet::Node::Catalog.new("host")
         @compone = Puppet::Type::Component.create :name => "one"
         @comptwo = Puppet::Type::Component.create :name => "two", :require => ["class", "one"]
         @file = Puppet::Type.type(:file)
         @one = @file.create :path => "/one"
         @two = @file.create :path => "/two"
         @catalog.add_edge @compone, @one
         @catalog.add_edge @comptwo, @two
 
         @three = @file.create :path => "/three"
         @four = @file.create :path => "/four", :require => ["file", "/three"]
         @five = @file.create :path => "/five"
         @catalog.add_resource @compone, @comptwo, @one, @two, @three, @four, @five
         @relationships = @catalog.relationship_graph
     end
 
     it "should fail when trying to create a relationship graph for a relationship graph" do
         proc { @relationships.relationship_graph }.should raise_error(Puppet::DevError)
     end
 
     it "should be able to create a relationship graph" do
         @relationships.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should copy its host_config setting to the relationship graph" do
         config = Puppet::Node::Catalog.new
         config.host_config = true
         config.relationship_graph.host_config.should be_true
     end
 
     it "should not have any components" do
         @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil
     end
 
     it "should have all non-component resources from the catalog" do
         # The failures print out too much info, so i just do a class comparison
         @relationships.vertex?(@five).should be_true
     end
 
     it "should have all resource relationships set as edges" do
         @relationships.edge?(@three, @four).should be_true
     end
 
     it "should copy component relationships to all contained resources" do
         @relationships.edge?(@one, @two).should be_true
     end
 
     it "should get removed when the catalog is cleaned up" do
         @relationships.expects(:clear).with(false)
         @catalog.clear
         @catalog.instance_variable_get("@relationship_graph").should be_nil
     end
 
     it "should create a new relationship graph after clearing the old one" do
         @relationships.expects(:clear).with(false)
         @catalog.clear
         @catalog.relationship_graph.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should look up resources in the relationship graph if not found in the main catalog" do
         five = stub 'five', :ref => "File[five]", :catalog= => nil
         @relationships.add_resource five
         @catalog.resource(five.ref).should equal(five)
     end
 
     it "should provide a method to create additional resources that also registers the resource" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         @catalog.create_resource :file, args
         @catalog.resource("File[/yay]").should equal(resource)
     end
 
     it "should provide a mechanism for creating implicit resources" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         resource.expects(:implicit=).with(true)
         @catalog.create_implicit_resource :file, args
         @catalog.resource("File[/yay]").should equal(resource)
     end
 
     it "should add implicit resources to the relationship graph if there is one" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         resource.expects(:implicit=).with(true)
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         # build the graph
         relgraph = @catalog.relationship_graph
 
         @catalog.create_implicit_resource :file, args
         relgraph.resource("File[/yay]").should equal(resource)
     end
 
     it "should remove resources created mid-transaction" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         @transaction = mock 'transaction'
         Puppet::Transaction.stubs(:new).returns(@transaction)
         @transaction.stubs(:evaluate)
         @transaction.stubs(:cleanup)
         @transaction.stubs(:addtimes)
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         resource.expects :remove
         @catalog.apply do |trans|
             @catalog.create_resource :file, args
             @catalog.resource("File[/yay]").should equal(resource)
         end
         @catalog.resource("File[/yay]").should be_nil
     end
 
     it "should remove resources from the relationship graph if it exists" do
         @catalog.remove_resource(@one)
         @catalog.relationship_graph.vertex?(@one).should be_false
     end
 
     after do
         Puppet::Type.allclear
     end
 end
 
 describe Puppet::Node::Catalog, " when writing dot files" do
     before do
         @catalog = Puppet::Node::Catalog.new("host")
         @name = :test
         @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
     end
     it "should only write when it is a host catalog" do
         File.expects(:open).with(@file).never
         @catalog.host_config = false
         Puppet[:graph] = true
         @catalog.write_graph(@name)
     end
 
     it "should only write when graphing is enabled" do
         File.expects(:open).with(@file).never
         @catalog.host_config = true
         Puppet[:graph] = false
         @catalog.write_graph(@name)
     end
 
     it "should write a dot file based on the passed name" do
+        Puppet.settings.stubs(:use)
         File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil))
         @catalog.expects(:to_dot).with("name" => @name.to_s.capitalize)
         @catalog.host_config = true
         Puppet[:graph] = true
         @catalog.write_graph(@name)
     end
 
     after do
         Puppet.settings.clear
     end
 end
 
 describe Puppet::Node::Catalog, " when indirecting" do
     before do
         @indirection = stub 'indirection', :name => :catalog
 
         Puppet::Indirector::Indirection.clear_cache
     end
 
     it "should redirect to the indirection for retrieval" do
         Puppet::Node::Catalog.stubs(:indirection).returns(@indirection)
         @indirection.expects(:find)
         Puppet::Node::Catalog.find(:myconfig)
     end
 
     it "should default to the 'compiler' terminus" do
         Puppet::Node::Catalog.indirection.terminus_class.should == :compiler
     end
 
     after do
         mocha_verify
         Puppet::Indirector::Indirection.clear_cache
     end
 end
 
 describe Puppet::Node::Catalog, " when converting to yaml" do
     before do
         @catalog = Puppet::Node::Catalog.new("me")
         @catalog.add_edge("one", "two")
     end
 
     it "should be able to be dumped to yaml" do
         YAML.dump(@catalog).should be_instance_of(String)
     end
 end
 
 describe Puppet::Node::Catalog, " when converting from yaml" do
     before do
         @catalog = Puppet::Node::Catalog.new("me")
         @catalog.add_edge("one", "two")
 
         text = YAML.dump(@catalog)
         @newcatalog = YAML.load(text)
     end
 
     it "should get converted back to a catalog" do
         @newcatalog.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should have all vertices" do
         @newcatalog.vertex?("one").should be_true
         @newcatalog.vertex?("two").should be_true
     end
 
     it "should have all edges" do
         @newcatalog.edge?("one", "two").should be_true
     end
 end
diff --git a/spec/unit/other/transbucket.rb b/spec/unit/other/transbucket.rb
index 4494f2abb..0240a4473 100755
--- a/spec/unit/other/transbucket.rb
+++ b/spec/unit/other/transbucket.rb
@@ -1,172 +1,172 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::TransBucket do
     before do
         @bucket = Puppet::TransBucket.new
     end
 
     it "should be able to produce a RAL component" do
         @bucket.name = "luke"
         @bucket.type = "user"
 
         resource = nil
         proc { resource = @bucket.to_type }.should_not raise_error
         resource.should be_instance_of(Puppet::Type::Component)
         resource.title.should == "User[luke]"
     end
 
     it "should accept TransObjects into its children list" do
         object = Puppet::TransObject.new("luke", "user")
         proc { @bucket.push(object) }.should_not raise_error
         @bucket.each do |o|
             o.should equal(object)
         end
     end
 
     it "should accept TransBuckets into its children list" do
         object = Puppet::TransBucket.new()
         proc { @bucket.push(object) }.should_not raise_error
         @bucket.each do |o|
             o.should equal(object)
         end
     end
 
     it "should refuse to accept any children that are not TransObjects or TransBuckets" do
         proc { @bucket.push "a test" }.should raise_error
     end
 
     it "should return use 'node' as the type and the provided name as the title if only a type is provided" do
         @bucket.type = "mystuff"
         @bucket.to_ref.should == "Node[mystuff]"
     end
 
     it "should return use 'component' as the type and the provided type as the title if only a name is provided" do
         @bucket.name = "mystuff"
         @bucket.to_ref.should == "Class[mystuff]"
     end
 
     it "should return nil as its reference when type and name are missing" do
         @bucket.to_ref.should be_nil
     end
 
     it "should return the title as its reference" do
         @bucket.name = "luke"
         @bucket.type = "user"
         @bucket.to_ref.should == "User[luke]"
     end
 
     it "should canonize resource references when the type is 'component'" do
         @bucket.name = 'something'
         @bucket.type = 'foo::bar'
 
         @bucket.to_ref.should == "Foo::Bar[something]"
     end
 end
 
 describe Puppet::TransBucket, " when generating a catalog" do
     before do
         @bottom = Puppet::TransBucket.new
         @bottom.type = "fake"
         @bottom.name = "bottom"
-        @bottomobj = Puppet::TransObject.new("bottom", "user")
+        @bottomobj = Puppet::TransObject.new("bottom", "notify")
         @bottom.push @bottomobj
 
         @middle = Puppet::TransBucket.new
         @middle.type = "fake"
         @middle.name = "middle"
-        @middleobj = Puppet::TransObject.new("middle", "user")
+        @middleobj = Puppet::TransObject.new("middle", "notify")
         @middle.push(@middleobj)
         @middle.push(@bottom)
 
         @top = Puppet::TransBucket.new
         @top.type = "fake"
         @top.name = "top"
-        @topobj = Puppet::TransObject.new("top", "user")
+        @topobj = Puppet::TransObject.new("top", "notify")
         @top.push(@topobj)
         @top.push(@middle)
 
         @users = %w{top middle bottom}
         @fakes = %w{Fake[bottom] Fake[middle] Fake[top]}
     end
 
     after do
         Puppet::Type.allclear
     end
 
     it "should convert all transportable objects to RAL resources" do
         @catalog = @top.to_catalog
         @users.each do |name|
-            @catalog.vertices.find { |r| r.class.name == :user and r.title == name }.should be_instance_of(Puppet::Type.type(:user))
+            @catalog.vertices.find { |r| r.class.name == :notify and r.title == name }.should be_instance_of(Puppet::Type.type(:notify))
         end
     end
 
     it "should fail if any transportable resources fail to convert to RAL resources" do
         @bottomobj.expects(:to_type).raises ArgumentError
         lambda { @bottom.to_catalog }.should raise_error(ArgumentError)
     end
 
     it "should convert all transportable buckets to RAL components" do
         @catalog = @top.to_catalog
         @fakes.each do |name|
             @catalog.vertices.find { |r| r.class.name == :component and r.title == name }.should be_instance_of(Puppet::Type.type(:component))
         end
     end
 
     it "should add all resources to the graph's resource table" do
         @catalog = @top.to_catalog
         @catalog.resource("fake[top]").should equal(@top)
     end
 
     it "should finalize all resources" do
         @catalog = @top.to_catalog
         @catalog.vertices.each do |vertex| vertex.should be_finalized end
     end
 
     it "should only call to_type on each resource once" do
         # We just raise exceptions here because we're not interested in
         # what happens with the result, only that the method only
         # gets called once.
         resource = @topobj.to_type
         @topobj.expects(:to_type).once.returns resource
         @top.to_catalog
     end
 
     it "should set each TransObject's catalog before converting to a RAL resource" do
         @middleobj.expects(:catalog=).with { |c| c.is_a?(Puppet::Node::Catalog) }
         @top.to_catalog
     end
 
     it "should set each TransBucket's catalog before converting to a RAL resource" do
         # each bucket is seen twice in the loop, so we have to handle the case where the config
         # is set twice
         @bottom.expects(:catalog=).with { |c| c.is_a?(Puppet::Node::Catalog) }.at_least_once
         @top.to_catalog
     end
 end
 
 describe Puppet::TransBucket, " when serializing" do
     before do
         @bucket = Puppet::TransBucket.new(%w{one two})
         @bucket.name = "one"
         @bucket.type = "two"
     end
 
     it "should be able to be dumped to yaml" do
         proc { YAML.dump(@bucket) }.should_not raise_error
     end
 
     it "should dump YAML that produces an equivalent object" do
         result = YAML.dump(@bucket)
 
         newobj = YAML.load(result)
         newobj.name.should == "one"
         newobj.type.should == "two"
         children = []
         newobj.each do |o|
             children << o
         end
         children.should == %w{one two}
     end
 end
diff --git a/spec/unit/provider/mount/parsed.rb b/spec/unit/provider/mount/parsed.rb
index df0e992f8..66891e6bf 100755
--- a/spec/unit/provider/mount/parsed.rb
+++ b/spec/unit/provider/mount/parsed.rb
@@ -1,185 +1,186 @@
 #!/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
         return fakefile(File::join("data/types/mount", name))
     end
 
     def mkmountargs
         mount = nil
 
         if defined? @pcount
             @pcount += 1
         else
             @pcount = 1
         end
         args = {
             :name => "/fspuppet%s" % @pcount,
             :device => "/dev/dsk%s" % @pcount,
         }
 
         @provider_class.fields(:parsed).each do |field|
             unless args.include? field
                 args[field] = "fake%s%s" % [field, @pcount]
             end
         end
 
         return args
     end
 
     def mkmount
         hash = mkmountargs()
         #hash[:provider] = @provider_class.name
 
         fakeresource = stub :type => :mount, :name => hash[: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
 
         return 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(: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
     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))
 
             @mount = mkmount
             @target = @provider_class.default_target
         end
 
         it "should write the mount to disk when :flush is called" do
             @mount.flush
 
             text = @provider_class.target_object(@provider_class.default_target).read
             text.should == @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.create :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
 
         after do
             Puppet::Type.allclear
         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/rails.rb b/spec/unit/rails.rb
index 382f7c0f4..694bb55c7 100755
--- a/spec/unit/rails.rb
+++ b/spec/unit/rails.rb
@@ -1,125 +1,126 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/rails'
 
 describe Puppet::Rails, "when initializing any connection" do
     confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
     before do
+        Puppet.settings.stubs(:use)
         @logger = mock 'logger'
         @logger.stub_everything
         Logger.stubs(:new).returns(@logger)
 
         ActiveRecord::Base.stubs(:logger).returns(@logger)
     end
 
     it "should use settings" do
         Puppet.settings.expects(:use).with(:main, :rails, :puppetmasterd)
         
         Puppet::Rails.connect
     end
     
     it "should set up a logger with the appropriate Rails log file" do
         logger = mock 'logger'
         Logger.expects(:new).with(Puppet[:railslog]).returns(logger)
         ActiveRecord::Base.expects(:logger=).with(logger)
         
         Puppet::Rails.connect
     end
     
     it "should set the log level to whatever the value is in the settings" do
         Puppet.settings.stubs(:use)
         Puppet.settings.stubs(:value).with(:rails_loglevel).returns("debug")
         Puppet.settings.stubs(:value).with(:railslog).returns("/my/file")
         logger = mock 'logger'
         Logger.stubs(:new).returns(logger)
         ActiveRecord::Base.stubs(:logger).returns(logger)
         logger.expects(:level=).with(Logger::DEBUG)
 
         ActiveRecord::Base.stubs(:allow_concurrency=)
         ActiveRecord::Base.stubs(:verify_active_connections!)
         ActiveRecord::Base.stubs(:establish_connection)
         Puppet::Rails.stubs(:database_arguments)
         
         Puppet::Rails.connect
     end
     
     it "should set ActiveRecord::Base.allow_concurrency" do
         ActiveRecord::Base.expects(:allow_concurrency=).with(true)
         
         Puppet::Rails.connect
     end
     
     it "should call ActiveRecord::Base.verify_active_connections!" do
         ActiveRecord::Base.expects(:verify_active_connections!)
         
         Puppet::Rails.connect
     end
     
     it "should call ActiveRecord::Base.establish_connection with database_arguments" do
         Puppet::Rails.expects(:database_arguments)
         ActiveRecord::Base.expects(:establish_connection)
         
         Puppet::Rails.connect
     end
 end
 
 describe Puppet::Rails, "when initializing a sqlite3 connection" do
     confine Puppet.features.rails? => "Cannot test without ActiveRecord" 
 
     it "should provide the adapter, log_level, and dbfile arguments" do
         Puppet.settings.expects(:value).with(:dbadapter).returns("sqlite3")
         Puppet.settings.expects(:value).with(:rails_loglevel).returns("testlevel")
         Puppet.settings.expects(:value).with(:dblocation).returns("testlocation")
         
         Puppet::Rails.database_arguments.should == {
             :adapter => "sqlite3",
             :log_level => "testlevel",
             :dbfile => "testlocation"
         }
     end
 end
 
 describe Puppet::Rails, "when initializing a mysql or postgresql connection" do
     confine Puppet.features.rails? => "Cannot test without ActiveRecord" 
 
     it "should provide the adapter, log_level, and host, username, password, and database arguments" do
         Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
         Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
         Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
         Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
         Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
         Puppet.settings.stubs(:value).with(:dbname).returns("testname")
         Puppet.settings.stubs(:value).with(:dbsocket).returns("")
         
         Puppet::Rails.database_arguments.should == {
             :adapter => "mysql",
             :log_level => "testlevel",
             :host => "testserver",
             :username => "testuser",
             :password => "testpassword",
             :database => "testname"
         }
     end
     
     it "should provide the adapter, log_level, and host, username, password, database, and socket arguments" do
         Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
         Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
         Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
         Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
         Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
         Puppet.settings.stubs(:value).with(:dbname).returns("testname")
         Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
         
         Puppet::Rails.database_arguments.should == {
             :adapter => "mysql",
             :log_level => "testlevel",
             :host => "testserver",
             :username => "testuser",
             :password => "testpassword",
             :database => "testname",
             :socket => "testsocket"
         }
     end
 end
diff --git a/spec/unit/type/file.rb b/spec/unit/type/file.rb
index 0b7bfa8fb..da03dd349 100755
--- a/spec/unit/type/file.rb
+++ b/spec/unit/type/file.rb
@@ -1,155 +1,157 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:file) do
     before do
+        Puppet.settings.stubs(:use)
+
         @path = Tempfile.new("puppetspec")
         @path.close!()
         @path = @path.path
         @file = Puppet::Type::File.create(:name => @path)
     end
 
     describe "when used with content and replace=>false" do
         before do
             @file[:content] = "foo"
             @file[:replace] = false
         end
 
         it "should be insync if the file exists and the content is different" do
             File.open(@path, "w") do |f| f.puts "bar" end
             @file.property(:content).insync?("bar").should be_true
         end
 
         it "should be insync if the file exists and the content is right" do
             File.open(@path, "w") do |f| f.puts "foo" end
             @file.property(:content).insync?("foo").should be_true
         end
 
         it "should not be insync if the file does not exist" do
             @file.property(:content).insync?(:nil).should be_false
         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
 
         it "should have a checksum type of md5 and warn if retrieving with mtime" do
             File.open(@path, "w") do |f| f.puts "foo" end
             @file.property(:checksum).expects(:warning).with("Files with source set must use md5 as checksum. Forcing to md5 from %s for %s" % [:mtime, @path]) 
             @file[:checksum] = :mtime
             @file.property(:checksum).checktype.should == :md5
             @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
         end
 
         it "should have a checksum type of md5 and warn if retrieving with md5lite" do
             File.open(@path, "w") do |f| f.puts "foo" end
             @file.property(:checksum).expects(:warning).with("Files with source set must use md5 as checksum. Forcing to md5 from %s for %s" % [:md5lite, @path]) 
             @file[:checksum] = :md5lite
             @file.property(:checksum).checktype.should == :md5
             @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
         end
 
 
         it "should have a checksum type of md5 if getsum called with mtime" do
             File.open(@path, "w") do |f| f.puts "foo" end
             @file[:checksum] = :md5
             @file.property(:checksum).checktype.should == :md5
             @file.property(:checksum).getsum(:mtime).should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
         end
 
         it "should not warn if sumtype set to md5" do
             File.open(@path, "w") do |f| f.puts "foo" end
             @file.property(:checksum).expects(:warning).never
             @file[:checksum] = :md5
             @file.property(:checksum).checktype.should == :md5
             @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
         end
 
     end
 
     describe "when retrieving remote files" do
         before do
             @filesource = Puppet::Type::File::FileSource.new
             @filesource.server = mock 'fileserver'
 
             @file.stubs(:uri2obj).returns(@filesource)
 
             @file[:source] = "puppet:///test"
         end
 
         it "should fail without writing if it cannot retrieve remote contents" do
             # create the file, because we only get the problem when it starts
             # out absent.
             File.open(@file[:path], "w") { |f| f.puts "a" }
             @file.expects(:write).never
 
             @filesource.server.stubs(:describe).returns("493\tfile\t100\t0\t{md5}3f5fef3bddbc4398c46a7bd7ba7b3af7")
             @filesource.server.stubs(:retrieve).raises(RuntimeError)
             @file.property(:source).retrieve
             lambda { @file.property(:source).sync }.should raise_error(Puppet::Error)
         end
 
         it "should fail if it cannot describe remote contents" do
             @filesource.server.stubs(:describe).raises(Puppet::Network::XMLRPCClientError.new("Testing"))
             lambda { @file.retrieve }.should raise_error(Puppet::Error)
         end
 
         it "should fail during eval_generate if no remote sources exist" do
             file = Puppet::Type.type(:file).create :path => "/foobar", :source => "/this/file/does/not/exist", :recurse => true
 
             lambda { file.eval_generate }.should raise_error(Puppet::Error)
         end
     end
 
     describe "when managing links" do
         require 'puppettest/support/assertions'
         include PuppetTest
         require 'tempfile'
 
         before do
             @basedir = tempfile
             Dir.mkdir(@basedir)
             @file = File.join(@basedir, "file")
             @link = File.join(@basedir, "link")
 
             File.open(@file, "w", 0644) { |f| f.puts "yayness"; f.flush }
             File.symlink(@file, @link)
 
             @resource = Puppet.type(:file).create(
                 :path => @link,
                 :mode => "755"
             )
             @catalog = Puppet::Node::Catalog.new
             @catalog.add_resource @resource
         end
 
         after do
             remove_tmp_files
         end
 
         it "should default to managing the link" do
             @catalog.apply
             # I convert them to strings so they display correctly if there's an error.
             ("%o" % (File.stat(@file).mode & 007777)).should == "%o" % 0644
         end
 
         it "should be able to follow links" do
             @resource[:links] = :follow
             @catalog.apply
 
             ("%o" % (File.stat(@file).mode & 007777)).should == "%o" % 0755
         end
     end
 
     after do
         Puppet::Type::File.clear
     end
 end
diff --git a/spec/unit/type/group.rb b/spec/unit/type/group.rb
index d7e06dcd8..66a7daf06 100755
--- a/spec/unit/type/group.rb
+++ b/spec/unit/type/group.rb
@@ -1,40 +1,43 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:group) do
     before do
+        unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
+            ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin"
+        end
         @class = Puppet::Type.type(:group)
     end
 
     after do
         @class.clear
     end
 
     it "should have a default provider" do
         @class.defaultprovider.should_not be_nil
     end
 
     it "should have a default provider inheriting from Puppet::Provider" do
         @class.defaultprovider.ancestors.should be_include(Puppet::Provider)
     end
 
     describe "when validating attributes" do
         [:name, :allowdupe].each do |param|
             it "should have a #{param} parameter" do
                 @class.attrtype(param).should == :param
             end
         end
 
         [:ensure, :gid].each do |param|
             it "should have a #{param} property" do
                 @class.attrtype(param).should == :property
             end
         end
     end
 
     # #1407 - we need to declare the allowdupe param as boolean.
     it "should have a boolean method for determining if duplicates are allowed" do
         @class.create(:name => "foo").methods.should be_include("allowdupe?")
     end
 end
diff --git a/spec/unit/type/noop_metaparam.rb b/spec/unit/type/noop_metaparam.rb
index 8510a1b6b..73fed53c1 100755
--- a/spec/unit/type/noop_metaparam.rb
+++ b/spec/unit/type/noop_metaparam.rb
@@ -1,38 +1,39 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/type'
 
 describe Puppet::Type.type(:file).attrclass(:noop) do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Type.newfile :path => "/what/ever"
     end
 
     after { Puppet::Type::File.clear }
 
     it "should accept true as a value" do
         lambda { @file[:noop] = true }.should_not raise_error
     end
 
     it "should accept false as a value" do
         lambda { @file[:noop] = false }.should_not raise_error
     end
 
     describe "when set on a resource" do
         it "should default to the :noop setting" do
             Puppet.settings.expects(:value).with(:noop).returns "myval"
             @file.noop.should == "myval"
         end
 
         it "should prefer true values from the attribute" do
             @file[:noop] = true
             @file.noop.should be_true
         end
 
         it "should prefer false values from the attribute" do
             @file[:noop] = false
             @file.noop.should be_false
         end
     end
 end
diff --git a/spec/unit/type/tidy.rb b/spec/unit/type/tidy.rb
index 9bcae86d7..3d0ff172b 100755
--- a/spec/unit/type/tidy.rb
+++ b/spec/unit/type/tidy.rb
@@ -1,68 +1,72 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 tidy = Puppet::Type.type(:tidy)
 
 describe tidy do
+    before do
+        Puppet.settings.stubs(:use)
+    end
+
     after { tidy.clear }
     
     it "should be in sync if the targeted file does not exist" do
         File.expects(:lstat).with("/tmp/foonesslaters").raises Errno::ENOENT
         @tidy = tidy.create :path => "/tmp/foonesslaters", :age => "100d"
 
         @tidy.property(:ensure).must be_insync({})
     end
 
     [:ensure, :age, :size].each do |property|
         it "should have a %s property" % property do
             tidy.attrclass(property).ancestors.should be_include(Puppet::Property)
         end
 
         it "should have documentation for its %s property" % property do
             tidy.attrclass(property).doc.should be_instance_of(String)
         end
     end
 
     [:path, :matches, :type, :recurse, :rmdirs].each do |param|
         it "should have a %s parameter" % param do
             tidy.attrclass(param).ancestors.should be_include(Puppet::Parameter)
         end
 
         it "should have documentation for its %s param" % param do
             tidy.attrclass(param).doc.should be_instance_of(String)
         end
     end
 
     describe "when validating parameter values" do
         describe "for 'recurse'" do
             before do
                 @tidy = tidy.create :path => "/tmp", :age => "100d"
             end
 
             it "should allow 'true'" do
                 lambda { @tidy[:recurse] = true }.should_not raise_error
             end
 
             it "should allow 'false'" do
                 lambda { @tidy[:recurse] = false }.should_not raise_error
             end
 
             it "should allow integers" do
                 lambda { @tidy[:recurse] = 10 }.should_not raise_error
             end
 
             it "should allow string representations of integers" do
                 lambda { @tidy[:recurse] = "10" }.should_not raise_error
             end
 
             it "should allow 'inf'" do
                 lambda { @tidy[:recurse] = "inf" }.should_not raise_error
             end
 
             it "should not allow arbitrary values" do
                 lambda { @tidy[:recurse] = "whatever" }.should raise_error
             end
         end
     end
 end
diff --git a/spec/unit/type/user.rb b/spec/unit/type/user.rb
index dadcc65ef..4f4f2c0eb 100755
--- a/spec/unit/type/user.rb
+++ b/spec/unit/type/user.rb
@@ -1,274 +1,277 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 user = Puppet::Type.type(:user)
 
 describe user do
     before do
+        unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
+            ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin"
+        end
         @provider = stub 'provider'
         @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
     end
 
     after { user.clear }
 
     it "should have a default provider inheriting from Puppet::Provider" do
         user.defaultprovider.ancestors.should be_include(Puppet::Provider)
     end
 
     it "should be able to create a instance" do
         user.create(:name => "foo").should_not be_nil
     end
 
     it "should have an allows_duplicates feature" do
         user.provider_feature(:allows_duplicates).should_not be_nil
     end
 
     it "should have an manages_homedir feature" do
         user.provider_feature(:manages_homedir).should_not be_nil
     end
 
     it "should have an manages_passwords feature" do
         user.provider_feature(:manages_passwords).should_not be_nil
     end
 
     it "should have a manages_solaris_rbac feature" do
         user.provider_feature(:manages_solaris_rbac).should_not be_nil
     end
 
     describe "instances" do
         it "should have a valid provider" do
             user.create(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
         end
     end
 
     properties = [:ensure, :uid, :gid, :home, :comment, :shell, :password, :groups, :roles, :auths, :profiles, :project, :keys]
 
     properties.each do |property|
         it "should have a %s property" % property do
             user.attrclass(property).ancestors.should be_include(Puppet::Property)
         end
 
         it "should have documentation for its %s property" % property do
             user.attrclass(property).doc.should be_instance_of(String)
         end
     end
 
     list_properties = [:groups, :roles, :auths]
 
     list_properties.each do |property|
         it "should have a list '%s'" % property do
             user.attrclass(property).ancestors.should be_include(Puppet::Property::List)
         end
     end
 
     it "should have an ordered list 'profiles'" do
         user.attrclass(:profiles).ancestors.should be_include(Puppet::Property::OrderedList)
     end
 
     it "should have key values 'keys'" do
         user.attrclass(:keys).ancestors.should be_include(Puppet::Property::KeyValue)
     end
 
     describe "when retrieving all current values" do
         before do
             @user = user.create(:name => "foo", :uid => 10, :gid => 10)
             @properties = {}
         end
 
         it "should return a hash containing values for all set properties" do
             values = @user.retrieve
             [@user.property(:uid), @user.property(:gid)].each { |property| values.should be_include(property) }
         end
 
         it "should set all values to :absent if the user is absent" do
             @user.property(:ensure).expects(:retrieve).returns :absent
             @user.property(:uid).expects(:retrieve).never
             @user.retrieve[@user.property(:uid)].should == :absent
         end
 
         it "should include the result of retrieving each property's current value if the user is present" do
             @user.property(:ensure).expects(:retrieve).returns :present
             @user.property(:uid).expects(:retrieve).returns 15
             @user.retrieve[@user.property(:uid)].should == 15
         end
     end
 
     describe "when managing the ensure property" do
         before do
             @ensure = user.attrclass(:ensure).new(:resource => @resource)
         end
 
         it "should support a :present value" do
             lambda { @ensure.should = :present }.should_not raise_error
         end
 
         it "should support an :absent value" do
             lambda { @ensure.should = :absent }.should_not raise_error
         end
 
         it "should call :create on the provider when asked to sync to the :present state" do
             @provider.expects(:create)
             @ensure.should = :present
             @ensure.sync
         end
 
         it "should call :delete on the provider when asked to sync to the :absent state" do
             @provider.expects(:delete)
             @ensure.should = :absent
             @ensure.sync
         end
 
         describe "and determining the current state" do
             it "should return :present when the provider indicates the user exists" do
                 @provider.expects(:exists?).returns true
                 @ensure.retrieve.should == :present
             end
 
             it "should return :absent when the provider indicates the user does not exist" do
                 @provider.expects(:exists?).returns false
                 @ensure.retrieve.should == :absent
             end
         end
     end
 
     describe "when managing the uid property" do
         it "should convert number-looking strings into actual numbers" do
             uid = user.attrclass(:uid).new(:resource => @resource)
             uid.should = "50"
             uid.should.must == 50
         end
 
         it "should support UIDs as numbers" do
             uid = user.attrclass(:uid).new(:resource => @resource)
             uid.should = 50
             uid.should.must == 50
         end
 
         it "should :absent as a value" do
             uid = user.attrclass(:uid).new(:resource => @resource)
             uid.should = :absent
             uid.should.must == :absent
         end
     end
 
     describe "when managing the gid" do
         it "should :absent as a value" do
             gid = user.attrclass(:gid).new(:resource => @resource)
             gid.should = :absent
             gid.should.must == :absent
         end
 
         it "should convert number-looking strings into actual numbers" do
             gid = user.attrclass(:gid).new(:resource => @resource)
             gid.should = "50"
             gid.should.must == 50
         end
 
         it "should support GIDs specified as integers" do
             gid = user.attrclass(:gid).new(:resource => @resource)
             gid.should = 50
             gid.should.must == 50
         end
 
         it "should support groups specified by name" do
             gid = user.attrclass(:gid).new(:resource => @resource)
             gid.should = "foo"
             gid.should.must == "foo"
         end
 
         describe "when testing whether in sync" do
             before do
                 @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
             end
 
             it "should return true if no 'should' values are set" do
                 @gid = user.attrclass(:gid).new(:resource => @resource)
 
                 @gid.must be_insync(500)
             end
 
             it "should return true if any of the specified groups are equal to the current integer" do
                 Puppet::Util.expects(:gid).with("foo").returns 300
                 Puppet::Util.expects(:gid).with("bar").returns 500
 
                 @gid.must be_insync(500)
             end
 
             it "should return false if none of the specified groups are equal to the current integer" do
                 Puppet::Util.expects(:gid).with("foo").returns 300
                 Puppet::Util.expects(:gid).with("bar").returns 500
 
                 @gid.should_not be_insync(700)
             end
         end
 
         describe "when syncing" do
             before do
                 @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
             end
 
             it "should use the first found, specified group as the desired value and send it to the provider" do
                 Puppet::Util.expects(:gid).with("foo").returns nil
                 Puppet::Util.expects(:gid).with("bar").returns 500
 
                 @provider.expects(:gid=).with 500
 
                 @gid.sync
             end
         end
     end
 
     describe "when managing passwords" do
         before do
             @password = user.attrclass(:password).new(:resource => @resource, :should => "mypass")
         end
 
         it "should not include the password in the change log when adding the password" do
             @password.change_to_s(:absent, "mypass").should_not be_include("mypass")
         end
 
         it "should not include the password in the change log when changing the password" do
             @password.change_to_s("other", "mypass").should_not be_include("mypass")
         end
 
         it "should fail if a ':' is included in the password" do
             lambda { @password.should = "some:thing" }.should raise_error(ArgumentError)
         end
 
         it "should allow the value to be set to :absent" do
             lambda { @password.should = :absent }.should_not raise_error
         end
     end
 
     describe "when manages_solaris_rbac is enabled" do
         before do
             @provider.stubs(:satisfies?).returns(false)
             @provider.expects(:satisfies?).with(:manages_solaris_rbac).returns(true)
         end
 
         it "should support a :role value for ensure" do
             @ensure = user.attrclass(:ensure).new(:resource => @resource)
             lambda { @ensure.should = :role }.should_not raise_error
         end
     end
 
     describe "when user has roles" do
         it "should autorequire roles" do
             #this is a little funky because the autorequire depends on a property with a feature
             testuser = Puppet.type(:user).create(:name => "testuser")
             testuser.provider.class.expects(:feature?).with(:manages_solaris_rbac).returns(true)
             testuser[:roles] = "testrole"
 
             testrole = Puppet.type(:user).create(:name => "testrole")
 
             config = Puppet::Node::Catalog.new :testing do |conf|
                 [testuser, testrole].each { |resource| conf.add_resource resource }
             end
 
             rel = testuser.autorequire[0]
             rel.source.ref.should == testrole.ref
             rel.target.ref.should == testuser.ref
         end
     end
 end