diff --git a/Rakefile b/Rakefile
index 8e21cebd9..728f1e3de 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,54 +1,54 @@
 # Rakefile for Puppet -*- ruby -*-
 
 $LOAD_PATH << File.join(File.dirname(__FILE__), 'tasks')
 
 require 'rake'
 require 'rake/packagetask'
 require 'rake/gempackagetask'
-require 'spec'
-require 'spec/rake/spectask'
+require 'rspec'
+require "rspec/core/rake_task"
 
 module Puppet
     PUPPETVERSION = File.read('lib/puppet.rb')[/PUPPETVERSION *= *'(.*)'/,1] or fail "Couldn't find PUPPETVERSION"
 end
 
 Dir['tasks/**/*.rake'].each { |t| load t }
 
 FILES = FileList[
     '[A-Z]*',
     'install.rb',
     'bin/**/*',
     'sbin/**/*',
     'lib/**/*',
     'conf/**/*',
     'man/**/*',
     'examples/**/*',
     'ext/**/*',
     'tasks/**/*',
     'test/**/*',
     'spec/**/*'
 ]
 
 Rake::PackageTask.new("puppet", Puppet::PUPPETVERSION) do |pkg|
     pkg.package_dir = 'pkg'
     pkg.need_tar_gz = true
     pkg.package_files = FILES.to_a
 end
 
 task :default do
     sh %{rake -T}
 end
 
 desc "Create the tarball and the gem - use when releasing"
 task :puppetpackages => [:create_gem, :package]
 
-Spec::Rake::SpecTask.new do |t|
-    t.spec_opts = ['--format','s', '--loadby','mtime','--color']
+RSpec::Core::RakeTask.new do |t|
+    t.rspec_opts = ['--format','s', '--color']
     t.pattern ='spec/{unit,integration}/**/*.rb'
     t.fail_on_error = false
 end
 
 desc "Run the unit tests"
 task :unit do
     sh "cd test; rake"
 end
diff --git a/spec/integration/application/apply_spec.rb b/spec/integration/application/apply_spec.rb
index 840917eff..363aa3469 100755
--- a/spec/integration/application/apply_spec.rb
+++ b/spec/integration/application/apply_spec.rb
@@ -1,33 +1,32 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet_spec/files'
 
 require 'puppet/application/apply'
 
 describe "apply" do
   include PuppetSpec::Files
 
-  describe "when applying provided catalogs" do
-    confine "PSON library is missing; cannot test applying catalogs" => Puppet.features.pson?
+  describe "when applying provided catalogs", :if => Puppet.features.pson? do
     it "should be able to apply catalogs provided in a file in pson" do
       file_to_create = tmpfile("pson_catalog")
       catalog = Puppet::Resource::Catalog.new
       resource = Puppet::Resource.new(:file, file_to_create, :parameters => {:content => "my stuff"})
       catalog.add_resource resource
 
       manifest = tmpfile("manifest")
 
       File.open(manifest, "w") { |f| f.print catalog.to_pson }
 
       puppet = Puppet::Application[:apply]
       puppet.options[:catalog] = manifest
 
       puppet.apply
 
       File.should be_exist(file_to_create)
       File.read(file_to_create).should == "my stuff"
     end
   end
 end
diff --git a/spec/integration/indirector/catalog/queue_spec.rb b/spec/integration/indirector/catalog/queue_spec.rb
index 0f8bd41fb..4581e3062 100755
--- a/spec/integration/indirector/catalog/queue_spec.rb
+++ b/spec/integration/indirector/catalog/queue_spec.rb
@@ -1,61 +1,58 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 require 'puppet/resource/catalog'
 
-
-describe "Puppet::Resource::Catalog::Queue" do
-  confine "Missing pson support; cannot test queue" => Puppet.features.pson?
-
+describe "Puppet::Resource::Catalog::Queue", :if => Puppet.features.pson? do
   before do
     Puppet::Resource::Catalog.indirection.terminus(:queue)
     @catalog = Puppet::Resource::Catalog.new
 
     @one = Puppet::Resource.new(:file, "/one")
     @two = Puppet::Resource.new(:file, "/two")
     @catalog.add_resource(@one, @two)
 
     @catalog.add_edge(@one, @two)
 
     Puppet[:trace] = true
   end
 
   after { Puppet.settings.clear }
 
   it "should render catalogs to pson and send them via the queue client when catalogs are saved" do
     terminus = Puppet::Resource::Catalog.indirection.terminus(:queue)
 
     client = mock 'client'
     terminus.stubs(:client).returns client
 
     client.expects(:send_message).with(:catalog, @catalog.to_pson)
 
     request = Puppet::Indirector::Request.new(:catalog, :save, "foo", :instance => @catalog)
 
     terminus.save(request)
   end
 
   it "should intern catalog messages when they are passed via a subscription" do
     client = mock 'client'
     Puppet::Resource::Catalog::Queue.stubs(:client).returns client
 
     pson = @catalog.to_pson
 
     client.expects(:subscribe).with(:catalog).yields(pson)
 
     Puppet.expects(:err).never
 
     result = []
     Puppet::Resource::Catalog::Queue.subscribe do |catalog|
       result << catalog
     end
 
     catalog = result.shift
     catalog.should be_instance_of(Puppet::Resource::Catalog)
 
     catalog.resource(:file, "/one").should be_instance_of(Puppet::Resource)
     catalog.resource(:file, "/two").should be_instance_of(Puppet::Resource)
     catalog.should be_edge(catalog.resource(:file, "/one"), catalog.resource(:file, "/two"))
   end
 end
diff --git a/spec/integration/network/formats_spec.rb b/spec/integration/network/formats_spec.rb
index e6cf28abb..d141abf00 100755
--- a/spec/integration/network/formats_spec.rb
+++ b/spec/integration/network/formats_spec.rb
@@ -1,110 +1,107 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/network/formats'
 
 class PsonIntTest
   attr_accessor :string
   def ==(other)
     other.class == self.class and string == other.string
   end
 
   def self.from_pson(data)
     new(data[0])
   end
 
   def initialize(string)
     @string = string
   end
 
   def to_pson(*args)
     {
       'type' => self.class.name,
       'data' => [@string]
     }.to_pson(*args)
   end
 
   def self.canonical_order(s)
     s.gsub(/\{"data":\[(.*?)\],"type":"PsonIntTest"\}/,'{"type":"PsonIntTest","data":[\1]}')
   end
 
 end
 
 describe Puppet::Network::FormatHandler.format(:s) do
   before do
     @format = Puppet::Network::FormatHandler.format(:s)
   end
 
   it "should support certificates" do
     @format.should be_supported(Puppet::SSL::Certificate)
   end
 
   it "should not support catalogs" do
     @format.should_not be_supported(Puppet::Resource::Catalog)
   end
 end
 
 describe Puppet::Network::FormatHandler.format(:pson) do
-  describe "when pson is absent" do
-    confine "'pson' library is present" => (! Puppet.features.pson?)
+  describe "when pson is absent", :if => (! Puppet.features.pson?) do
 
     before do
       @pson = Puppet::Network::FormatHandler.format(:pson)
     end
 
     it "should not be suitable" do
       @pson.should_not be_suitable
     end
   end
 
-  describe "when pson is available" do
-    confine "Missing 'pson' library" => Puppet.features.pson?
-
+  describe "when pson is available", :if => Puppet.features.pson? do
     before do
       @pson = Puppet::Network::FormatHandler.format(:pson)
     end
 
     it "should be able to render an instance to pson" do
       instance = PsonIntTest.new("foo")
       PsonIntTest.canonical_order(@pson.render(instance)).should == PsonIntTest.canonical_order('{"type":"PsonIntTest","data":["foo"]}' )
     end
 
     it "should be able to render arrays to pson" do
       @pson.render([1,2]).should == '[1,2]'
     end
 
     it "should be able to render arrays containing hashes to pson" do
       @pson.render([{"one"=>1},{"two"=>2}]).should == '[{"one":1},{"two":2}]'
     end
 
     it "should be able to render multiple instances to pson" do
       Puppet.features.add(:pson, :libs => ["pson"])
 
       one = PsonIntTest.new("one")
       two = PsonIntTest.new("two")
 
       PsonIntTest.canonical_order(@pson.render([one,two])).should == PsonIntTest.canonical_order('[{"type":"PsonIntTest","data":["one"]},{"type":"PsonIntTest","data":["two"]}]')
     end
 
     it "should be able to intern pson into an instance" do
       @pson.intern(PsonIntTest, '{"type":"PsonIntTest","data":["foo"]}').should == PsonIntTest.new("foo")
     end
 
     it "should be able to intern pson with no class information into an instance" do
       @pson.intern(PsonIntTest, '["foo"]').should == PsonIntTest.new("foo")
     end
 
     it "should be able to intern multiple instances from pson" do
       @pson.intern_multiple(PsonIntTest, '[{"type": "PsonIntTest", "data": ["one"]},{"type": "PsonIntTest", "data": ["two"]}]').should == [
         PsonIntTest.new("one"), PsonIntTest.new("two")
       ]
     end
 
     it "should be able to intern multiple instances from pson with no class information" do
       @pson.intern_multiple(PsonIntTest, '[["one"],["two"]]').should == [
         PsonIntTest.new("one"), PsonIntTest.new("two")
       ]
     end
   end
 end
diff --git a/spec/integration/network/server/mongrel_spec.rb b/spec/integration/network/server/mongrel_spec.rb
index cc90773e6..c2815b565 100755
--- a/spec/integration/network/server/mongrel_spec.rb
+++ b/spec/integration/network/server/mongrel_spec.rb
@@ -1,66 +1,65 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'puppet/network/server'
 require 'socket'
 
 describe Puppet::Network::Server do
-  describe "when using mongrel" do
-    confine "Mongrel is not available" => Puppet.features.mongrel?
+  describe "when using mongrel", :if => Puppet.features.mongrel? do
 
     before :each do
       Puppet[:servertype] = 'mongrel'
       Puppet[:server] = '127.0.0.1'
       @params = { :port => 34346, :handlers => [ :node ] }
       @server = Puppet::Network::Server.new(@params)
     end
 
     after { Puppet.settings.clear }
 
     describe "before listening" do
       it "should not be reachable at the specified address and port" do
         lambda { TCPSocket.new('127.0.0.1', 34346) }.should raise_error(Errno::ECONNREFUSED)
       end
     end
 
     describe "when listening" do
       it "should be reachable on the specified address and port" do
         @server.listen
         lambda { TCPSocket.new('127.0.0.1', 34346) }.should_not raise_error
       end
 
       it "should default to '127.0.0.1' as its bind address" do
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.stubs(:unlisten) # we're breaking listening internally, so we have to keep it from unlistening
         @server.send(:http_server).expects(:listen).with { |args| args[:address] == "127.0.0.1" }
         @server.listen
       end
 
       it "should use any specified bind address" do
         Puppet[:bindaddress] = "0.0.0.0"
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.stubs(:unlisten) # we're breaking listening internally, so we have to keep it from unlistening
         @server.send(:http_server).expects(:listen).with { |args| args[:address] == "0.0.0.0" }
         @server.listen
       end
 
       it "should not allow multiple servers to listen on the same address and port" do
         @server.listen
         @server2 = Puppet::Network::Server.new(@params)
         lambda { @server2.listen }.should raise_error
       end
     end
 
     describe "after unlistening" do
       it "should not be reachable on the port and address assigned" do
         @server.listen
         @server.unlisten
         lambda { TCPSocket.new('127.0.0.1', 34346) }.should raise_error(Errno::ECONNREFUSED)
       end
     end
 
     after :each do
       @server.unlisten if @server.listening?
     end
   end
 end
diff --git a/spec/integration/provider/package_spec.rb b/spec/integration/provider/package_spec.rb
index 736a34e68..472662d6b 100755
--- a/spec/integration/provider/package_spec.rb
+++ b/spec/integration/provider/package_spec.rb
@@ -1,26 +1,24 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 describe "Package Provider" do
   Puppet::Type.type(:package).providers.each do |name|
     provider = Puppet::Type.type(:package).provider(name)
 
-    describe name do
-      confine "Provider #{name} is not suitable" => provider.suitable?
-
+    describe name, :if => provider.suitable? do
       it "should fail when asked to install an invalid package" do
         pending("This test hangs forever with recent versions of RubyGems") if provider.name == :gem
         pkg = Puppet::Type.newpackage :name => "nosuch#{provider.name}", :provider => provider.name
         lambda { pkg.provider.install }.should raise_error
       end
 
       it "should be able to get a list of existing packages" do
         provider.instances.each do |package|
           package.should be_instance_of(provider)
           package.properties[:provider].should == provider.name
         end
       end
     end
   end
 end
diff --git a/spec/integration/provider/service/init_spec.rb b/spec/integration/provider/service/init_spec.rb
index d916ab32a..2e2505bd4 100755
--- a/spec/integration/provider/service/init_spec.rb
+++ b/spec/integration/provider/service/init_spec.rb
@@ -1,32 +1,26 @@
 #!/usr/bin/env ruby
 
 # Find and load the spec file.
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 provider = Puppet::Type.type(:service).provider(:init)
 
 describe provider do
-  describe "when running on FreeBSD" do
-    confine "Not running on FreeBSD" => (Facter.value(:operatingsystem) == "FreeBSD")
-
+  describe "when running on FreeBSD", :if => (Facter.value(:operatingsystem) == "FreeBSD") do
     it "should set its default path to include /etc/init.d and /usr/local/etc/init.d" do
       provider.defpath.should == ["/etc/rc.d", "/usr/local/etc/rc.d"]
     end
   end
 
-  describe "when running on HP-UX" do
-    confine "Not running on HP-UX" => (Facter.value(:operatingsystem) == "HP-UX")
-
+  describe "when running on HP-UX", :if => (Facter.value(:operatingsystem) == "HP-UX")do
     it "should set its default path to include /sbin/init.d" do
       provider.defpath.should == "/sbin/init.d"
     end
   end
 
-  describe "when not running on FreeBSD or HP-UX" do
-    confine "Running on HP-UX or FreeBSD" => (! %w{HP-UX FreeBSD}.include?(Facter.value(:operatingsystem)))
-
+  describe "when not running on FreeBSD or HP-UX", :if => (! %w{HP-UX FreeBSD}.include?(Facter.value(:operatingsystem))) do
     it "should set its default path to include /etc/init.d" do
       provider.defpath.should == "/etc/init.d"
     end
   end
 end
diff --git a/spec/integration/resource/catalog_spec.rb b/spec/integration/resource/catalog_spec.rb
index 0a3d47a80..da2b70409 100755
--- a/spec/integration/resource/catalog_spec.rb
+++ b/spec/integration/resource/catalog_spec.rb
@@ -1,61 +1,60 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-4-8.
 #  Copyright (c) 2008. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Resource::Catalog do
-  describe "when pson is available" do
-    confine "PSON library is missing" => Puppet.features.pson?
+  describe "when pson is available", :if => Puppet.features.pson? do
     it "should support pson" do
       Puppet::Resource::Catalog.supported_formats.should be_include(:pson)
     end
   end
 
   describe "when using the indirector" do
     after { Puppet::Util::Cacher.expire }
     before do
       # This is so the tests work w/out networking.
       Facter.stubs(:to_hash).returns({"hostname" => "foo.domain.com"})
       Facter.stubs(:value).returns("eh")
     end
 
 
     it "should be able to delegate to the :yaml terminus" do
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :yaml
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Resource::Catalog.indirection.terminus(:yaml)
       terminus.expects(:path).with("me").returns "/my/yaml/file"
 
       FileTest.expects(:exist?).with("/my/yaml/file").returns false
       Puppet::Resource::Catalog.find("me").should be_nil
     end
 
     it "should be able to delegate to the :compiler terminus" do
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :compiler
 
       # Load now, before we stub the exists? method.
       compiler = Puppet::Resource::Catalog.indirection.terminus(:compiler)
 
       node = mock 'node'
       node.stub_everything
 
       Puppet::Node.expects(:find).returns(node)
       compiler.expects(:compile).with(node).returns nil
 
       Puppet::Resource::Catalog.find("me").should be_nil
     end
 
     it "should pass provided node information directly to the terminus" do
       terminus = mock 'terminus'
 
       Puppet::Resource::Catalog.indirection.stubs(:terminus).returns terminus
 
       node = mock 'node'
       terminus.expects(:find).with { |request| request.options[:use_node] == node }
       Puppet::Resource::Catalog.find("me", :use_node => node)
     end
   end
 end
diff --git a/spec/monkey_patches/add_confine_and_runnable_to_rspec_dsl.rb b/spec/monkey_patches/add_confine_and_runnable_to_rspec_dsl.rb
deleted file mode 100644
index 3762b7033..000000000
--- a/spec/monkey_patches/add_confine_and_runnable_to_rspec_dsl.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-dir = File.expand_path(File.dirname(__FILE__))
-[ "#{dir}/../../lib", "#{dir}/../../test/lib"].each do |dir|
-    fulldir = File.expand_path(dir)
-    $LOAD_PATH.unshift(fulldir) unless $LOAD_PATH.include?(fulldir)
-end
-
-require 'spec'
-require 'puppettest/runnable_test'
-
-module Spec
-  module Runner
-    class ExampleGroupRunner
-      def run
-        prepare
-        success = true
-        example_groups.each do |example_group|
-          unless example_group.runnable?
-            warn "Skipping unsuitable example group #{example_group.description}: #{example_group.messages.join(", ")}"
-            next
-          end
-          success = success & example_group.run(@options)
-          Puppet.settings.clear
-        end
-        return success
-      ensure
-        finish
-      end
-    end
-  end
-end
-
-module Spec
-  module Example
-    class ExampleGroup
-      extend PuppetTest::RunnableTest
-    end
-  end
-end
-
-module Test
-  module Unit
-    class TestCase
-      extend PuppetTest::RunnableTest
-    end
-  end
-end
diff --git a/spec/monkey_patches/alias_should_to_must.rb b/spec/monkey_patches/alias_should_to_must.rb
index c8744136a..1a1111799 100644
--- a/spec/monkey_patches/alias_should_to_must.rb
+++ b/spec/monkey_patches/alias_should_to_must.rb
@@ -1,6 +1,8 @@
+require 'rspec'
+
 class Object
   # This is necessary because the RAL has a 'should'
   # method.
   alias :must :should
   alias :must_not :should_not
 end
diff --git a/spec/shared_behaviours/file_server_terminus.rb b/spec/shared_behaviours/file_server_terminus.rb
index 665b46cd5..94a044d2e 100644
--- a/spec/shared_behaviours/file_server_terminus.rb
+++ b/spec/shared_behaviours/file_server_terminus.rb
@@ -1,45 +1,45 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-10-18.
 #  Copyright (c) 2007. All rights reserved.
 
-describe "Puppet::Indirector::FileServerTerminus", :shared => true do
+shared_examples_for "Puppet::Indirector::FileServerTerminus" do
   # This only works if the shared behaviour is included before
   # the 'before' block in the including context.
   before do
     Puppet::Util::Cacher.expire
     FileTest.stubs(:exists?).returns true
     FileTest.stubs(:exists?).with(Puppet[:fileserverconfig]).returns(true)
 
     @path = Tempfile.new("file_server_testing")
     path = @path.path
     @path.close!
     @path = path
 
     Dir.mkdir(@path)
     File.open(File.join(@path, "myfile"), "w") { |f| f.print "my content" }
 
     # Use a real mount, so the integration is a bit deeper.
     @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
     @mount1.path = @path
 
     @parser = stub 'parser', :changed? => false
     @parser.stubs(:parse).returns("one" => @mount1)
 
     Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
 
     # Stub out the modules terminus
     @modules = mock 'modules terminus'
 
     @request = Puppet::Indirector::Request.new(:indirection, :method, "puppet://myhost/one/myfile")
   end
 
   it "should use the file server configuration to find files" do
     @modules.stubs(:find).returns(nil)
     @terminus.indirection.stubs(:terminus).with(:modules).returns(@modules)
 
     path = File.join(@path, "myfile")
 
     @terminus.find(@request).should be_instance_of(@test_class)
   end
 end
diff --git a/spec/shared_behaviours/file_serving.rb b/spec/shared_behaviours/file_serving.rb
index 5f5b2b0af..450fff87a 100644
--- a/spec/shared_behaviours/file_serving.rb
+++ b/spec/shared_behaviours/file_serving.rb
@@ -1,71 +1,71 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-10-18.
 #  Copyright (c) 2007. All rights reserved.
 
-describe "Puppet::FileServing::Files", :shared => true do
+shared_examples_for "Puppet::FileServing::Files" do
   it "should use the rest terminus when the 'puppet' URI scheme is used and a host name is present" do
     uri = "puppet://myhost/fakemod/my/file"
 
     # It appears that the mocking somehow interferes with the caching subsystem.
     # This mock somehow causes another terminus to get generated.
     term = @indirection.terminus(:rest)
     @indirection.stubs(:terminus).with(:rest).returns term
     term.expects(:find)
     @test_class.find(uri)
   end
 
   it "should use the rest terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is not 'puppet' or 'apply'" do
     uri = "puppet:///fakemod/my/file"
     Puppet.settings.stubs(:value).returns "foo"
     Puppet.settings.stubs(:value).with(:name).returns("puppetd")
     Puppet.settings.stubs(:value).with(:modulepath).returns("")
     @indirection.terminus(:rest).expects(:find)
     @test_class.find(uri)
   end
 
   it "should use the file_server terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is 'puppet'" do
     uri = "puppet:///fakemod/my/file"
     Puppet::Node::Environment.stubs(:new).returns(stub("env", :name => "testing", :module => nil, :modulepath => []))
     Puppet.settings.stubs(:value).returns ""
     Puppet.settings.stubs(:value).with(:name).returns("puppet")
     Puppet.settings.stubs(:value).with(:fileserverconfig).returns("/whatever")
     @indirection.terminus(:file_server).expects(:find)
     @indirection.terminus(:file_server).stubs(:authorized?).returns(true)
     @test_class.find(uri)
   end
 
   it "should use the file_server terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is 'apply'" do
     uri = "puppet:///fakemod/my/file"
     Puppet::Node::Environment.stubs(:new).returns(stub("env", :name => "testing", :module => nil, :modulepath => []))
     Puppet.settings.stubs(:value).returns ""
     Puppet.settings.stubs(:value).with(:name).returns("apply")
     Puppet.settings.stubs(:value).with(:fileserverconfig).returns("/whatever")
     @indirection.terminus(:file_server).expects(:find)
     @indirection.terminus(:file_server).stubs(:authorized?).returns(true)
     @test_class.find(uri)
   end
 
   it "should use the file terminus when the 'file' URI scheme is used" do
     uri = "file:///fakemod/my/file"
     @indirection.terminus(:file).expects(:find)
     @test_class.find(uri)
   end
 
   it "should use the file terminus when a fully qualified path is provided" do
     uri = "/fakemod/my/file"
     @indirection.terminus(:file).expects(:find)
     @test_class.find(uri)
   end
 
   it "should use the configuration to test whether the request is allowed" do
     uri = "fakemod/my/file"
     mount = mock 'mount'
     config = stub 'configuration', :split_path => [mount, "eh"]
     @indirection.terminus(:file_server).stubs(:configuration).returns config
 
     @indirection.terminus(:file_server).expects(:find)
     mount.expects(:allowed?).returns(true)
     @test_class.find(uri, :node => "foo", :ip => "bar")
   end
 end
diff --git a/spec/shared_behaviours/memory_terminus.rb b/spec/shared_behaviours/memory_terminus.rb
index 5c9f35cca..f9325a969 100644
--- a/spec/shared_behaviours/memory_terminus.rb
+++ b/spec/shared_behaviours/memory_terminus.rb
@@ -1,32 +1,32 @@
 #
 #  Created by Luke Kanies on 2008-4-8.
 #  Copyright (c) 2008. All rights reserved.
 
-describe "A Memory Terminus", :shared => true do
+shared_examples_for "A Memory Terminus" do
   it "should find no instances by default" do
     @searcher.find(@request).should be_nil
   end
 
   it "should be able to find instances that were previously saved" do
     @searcher.save(@request)
     @searcher.find(@request).should equal(@instance)
   end
 
   it "should replace existing saved instances when a new instance with the same name is saved" do
     @searcher.save(@request)
     two = stub 'second', :name => @name
     trequest = stub 'request', :key => @name, :instance => two
     @searcher.save(trequest)
     @searcher.find(@request).should equal(two)
   end
 
   it "should be able to remove previously saved instances" do
     @searcher.save(@request)
     @searcher.destroy(@request)
     @searcher.find(@request).should be_nil
   end
 
   it "should fail when asked to destroy an instance that does not exist" do
     proc { @searcher.destroy(@request) }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index ed4e2c2fb..d0ee7d92a 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,79 +1,77 @@
 unless defined?(SPEC_HELPER_IS_LOADED)
 SPEC_HELPER_IS_LOADED = 1
 
 dir = File.expand_path(File.dirname(__FILE__))
 
 $LOAD_PATH.unshift("#{dir}/")
 $LOAD_PATH.unshift("#{dir}/lib") # a spec-specific test lib dir
 $LOAD_PATH.unshift("#{dir}/../lib")
 
 # Don't want puppet getting the command line arguments for rake or autotest
 ARGV.clear
 
 require 'puppet'
 require 'mocha'
-gem 'rspec', '>=1.2.9'
-require 'spec/autorun'
+gem 'rspec', '>=2.0.0'
 
 # So everyone else doesn't have to include this base constant.
 module PuppetSpec
   FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
 end
 
 require 'lib/puppet_spec/files'
 require 'monkey_patches/alias_should_to_must'
-require 'monkey_patches/add_confine_and_runnable_to_rspec_dsl'
 require 'monkey_patches/publicize_methods'
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.mock_with :mocha
 
-  config.prepend_after :each do
+  config.after :each do
     Puppet.settings.clear
     Puppet::Node::Environment.clear
     Puppet::Util::Storage.clear
 
     if defined?($tmpfiles)
       $tmpfiles.each do |file|
         file = File.expand_path(file)
         if Puppet.features.posix? and file !~ /^\/tmp/ and file !~ /^\/var\/folders/
           puts "Not deleting tmpfile #{file} outside of /tmp or /var/folders"
           next
         elsif Puppet.features.microsoft_windows?
           tempdir = File.expand_path(File.join(Dir::LOCAL_APPDATA, "Temp"))
           if file !~ /^#{tempdir}/
             puts "Not deleting tmpfile #{file} outside of #{tempdir}"
             next
           end
         end
         if FileTest.exist?(file)
           system("chmod -R 755 '#{file}'")
           system("rm -rf '#{file}'")
         end
       end
       $tmpfiles.clear
     end
 
     @logs.clear
     Puppet::Util::Log.close_all
   end
 
-  config.prepend_before :each do
+  config.before :each do
     # these globals are set by Application
     $puppet_application_mode = nil
     $puppet_application_name = nil
 
     # Set the confdir and vardir to gibberish so that tests
     # have to be correctly mocked.
     Puppet[:confdir] = "/dev/null"
     Puppet[:vardir] = "/dev/null"
 
     # Avoid opening ports to the outside world
     Puppet.settings[:bindaddress] = "127.0.0.1"
 
     @logs = []
     Puppet::Util::Log.newdestination(@logs)
   end
 end
 
 end
diff --git a/spec/unit/application/kick_spec.rb b/spec/unit/application/kick_spec.rb
index dea7ec147..c18a84de3 100755
--- a/spec/unit/application/kick_spec.rb
+++ b/spec/unit/application/kick_spec.rb
@@ -1,313 +1,311 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/kick'
 
-describe Puppet::Application::Kick do
-
-  confine "Kick's eventloops can only start on POSIX" => Puppet.features.posix?
+describe Puppet::Application::Kick, :if => Puppet.features.posix? do
 
   before :each do
     require 'puppet/util/ldap/connection'
     Puppet::Util::Ldap::Connection.stubs(:new).returns(stub_everything)
     @kick = Puppet::Application[:kick]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:level=)
   end
 
   describe ".new" do
     it "should take a command-line object as an argument" do
       command_line = stub_everything "command_line"
       lambda{ Puppet::Application::Kick.new( command_line ) }.should_not raise_error
     end
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
     @kick.should_parse_config?.should be_false
   end
 
   it "should declare a main command" do
     @kick.should respond_to(:main)
   end
 
   it "should declare a test command" do
     @kick.should respond_to(:test)
   end
 
   it "should declare a preinit block" do
     @kick.should respond_to(:preinit)
   end
 
   describe "during preinit" do
     before :each do
       @kick.stubs(:trap)
     end
 
     it "should catch INT and TERM" do
       @kick.stubs(:trap).with { |arg,block| arg == :INT or arg == :TERM }
 
       @kick.preinit
     end
 
     it "should set parallel option to 1" do
       @kick.preinit
 
       @kick.options[:parallel].should == 1
     end
 
     it "should set verbose by default" do
       @kick.preinit
 
       @kick.options[:verbose].should be_true
     end
 
     it "should set fqdn by default" do
       @kick.preinit
 
       @kick.options[:fqdn].should be_true
     end
 
     it "should set ignoreschedules to 'false'" do
       @kick.preinit
 
       @kick.options[:ignoreschedules].should be_false
     end
 
     it "should set foreground to 'false'" do
       @kick.preinit
 
       @kick.options[:foreground].should be_false
     end
   end
 
   describe "when applying options" do
 
     before do
       @kick.preinit
     end
 
     [:all, :foreground, :debug, :ping, :test].each do |option|
       it "should declare handle_#{option} method" do
         @kick.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @kick.options.expects(:[]=).with(option, 'arg')
         @kick.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should add to the host list with the host option" do
       @kick.handle_host('host')
 
       @kick.hosts.should == ['host']
     end
 
     it "should add to the tag list with the tag option" do
       @kick.handle_tag('tag')
 
       @kick.tags.should == ['tag']
     end
 
     it "should add to the class list with the class option" do
       @kick.handle_class('class')
 
       @kick.classes.should == ['class']
     end
   end
 
   describe "during setup" do
 
     before :each do
       @kick.classes = []
       @kick.tags = []
       @kick.hosts = []
       Puppet::Log.stubs(:level=)
       @kick.stubs(:trap)
       @kick.stubs(:puts)
       Puppet.stubs(:parse_config)
 
       @kick.options.stubs(:[]).with(any_parameters)
     end
 
     it "should set log level to debug if --debug was passed" do
       @kick.options.stubs(:[]).with(:debug).returns(true)
 
       Puppet::Log.expects(:level=).with(:debug)
 
       @kick.setup
     end
 
     it "should set log level to info if --verbose was passed" do
       @kick.options.stubs(:[]).with(:verbose).returns(true)
 
       Puppet::Log.expects(:level=).with(:info)
 
       @kick.setup
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
       @kick.setup
     end
 
     describe "when using the ldap node terminus" do
       before :each do
         Puppet.stubs(:[]).with(:node_terminus).returns("ldap")
       end
 
       it "should pass the fqdn option to search" do
         @kick.options.stubs(:[]).with(:fqdn).returns(:something)
         @kick.options.stubs(:[]).with(:all).returns(true)
         @kick.stubs(:puts)
 
         Puppet::Node.expects(:search).with("whatever",:fqdn => :something).returns([])
 
         @kick.setup
       end
 
       it "should search for all nodes if --all" do
         @kick.options.stubs(:[]).with(:all).returns(true)
         @kick.stubs(:puts)
 
         Puppet::Node.expects(:search).with("whatever",:fqdn => nil).returns([])
 
         @kick.setup
       end
 
       it "should search for nodes including given classes" do
         @kick.options.stubs(:[]).with(:all).returns(false)
         @kick.stubs(:puts)
         @kick.classes = ['class']
 
         Puppet::Node.expects(:search).with("whatever", :class => "class", :fqdn => nil).returns([])
 
         @kick.setup
       end
     end
 
     describe "when using regular nodes" do
       it "should fail if some classes have been specified" do
         $stderr.stubs(:puts)
         @kick.classes = ['class']
 
         @kick.expects(:exit).with(24)
 
         @kick.setup
       end
     end
   end
 
   describe "when running" do
     before :each do
       @kick.stubs(:puts)
     end
 
     it "should dispatch to test if --test is used" do
       @kick.options.stubs(:[]).with(:test).returns(true)
 
       @kick.expects(:test)
       @kick.run_command
     end
 
     it "should dispatch to main if --test is not used" do
       @kick.options.stubs(:[]).with(:test).returns(false)
 
       @kick.expects(:main)
       @kick.run_command
     end
 
     describe "the test command" do
       it "should exit with exit code 0 " do
         @kick.expects(:exit).with(0)
 
         @kick.test
       end
     end
 
     describe "the main command" do
       before :each do
         @kick.options.stubs(:[]).with(:parallel).returns(1)
         @kick.options.stubs(:[]).with(:ping).returns(false)
         @kick.options.stubs(:[]).with(:ignoreschedules).returns(false)
         @kick.options.stubs(:[]).with(:foreground).returns(false)
         @kick.options.stubs(:[]).with(:debug).returns(false)
         @kick.stubs(:print)
         @kick.stubs(:exit)
         @kick.preinit
         @kick.stubs(:parse_options)
         @kick.setup
         $stderr.stubs(:puts)
       end
 
       it "should create as much childs as --parallel" do
         @kick.options.stubs(:[]).with(:parallel).returns(3)
         @kick.hosts = ['host1', 'host2', 'host3']
         @kick.stubs(:exit).raises(SystemExit)
         Process.stubs(:wait).returns(1).then.returns(2).then.returns(3).then.raises(Errno::ECHILD)
 
         @kick.expects(:fork).times(3).returns(1).then.returns(2).then.returns(3)
 
         lambda { @kick.main }.should raise_error
       end
 
       it "should delegate to run_for_host per host" do
         @kick.hosts = ['host1', 'host2']
         @kick.stubs(:exit).raises(SystemExit)
         @kick.stubs(:fork).returns(1).yields
         Process.stubs(:wait).returns(1).then.raises(Errno::ECHILD)
 
         @kick.expects(:run_for_host).times(2)
 
         lambda { @kick.main }.should raise_error
       end
 
       describe "during call of run_for_host" do
         before do
           require 'puppet/run'
           options = {
             :background => true, :ignoreschedules => false, :tags => []
           }
           @kick.preinit
           @agent_run = Puppet::Run.new( options.dup )
           @agent_run.stubs(:status).returns("success")
 
           Puppet::Run.indirection.expects(:terminus_class=).with( :rest )
           Puppet::Run.expects(:new).with( options ).returns(@agent_run)
         end
 
         it "should call run on a Puppet::Run for the given host" do
           @agent_run.expects(:save).with('https://host:8139/production/run/host').returns(@agent_run)
 
           @kick.run_for_host('host')
         end
 
         it "should exit the child with 0 on success" do
           @agent_run.stubs(:status).returns("success")
 
           @kick.expects(:exit).with(0)
 
           @kick.run_for_host('host')
         end
 
         it "should exit the child with 3 on running" do
           @agent_run.stubs(:status).returns("running")
 
           @kick.expects(:exit).with(3)
 
           @kick.run_for_host('host')
         end
 
         it "should exit the child with 12 on unknown answer" do
           @agent_run.stubs(:status).returns("whatever")
 
           @kick.expects(:exit).with(12)
 
           @kick.run_for_host('host')
         end
       end
     end
   end
 end
diff --git a/spec/unit/application/master_spec.rb b/spec/unit/application/master_spec.rb
index 216c7dc90..074249a4d 100644
--- a/spec/unit/application/master_spec.rb
+++ b/spec/unit/application/master_spec.rb
@@ -1,453 +1,451 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/master'
 require 'puppet/daemon'
 require 'puppet/network/server'
 
 describe Puppet::Application::Master do
   before :each do
     @master = Puppet::Application[:master]
     @daemon = stub_everything 'daemon'
     Puppet::Daemon.stubs(:new).returns(@daemon)
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:level=)
 
     Puppet::Node.stubs(:terminus_class=)
     Puppet::Node.stubs(:cache_class=)
     Puppet::Node::Facts.stubs(:terminus_class=)
     Puppet::Node::Facts.stubs(:cache_class=)
     Puppet::Transaction::Report.stubs(:terminus_class=)
     Puppet::Resource::Catalog.stubs(:terminus_class=)
   end
 
   it "should operate in master run_mode" do
     @master.class.run_mode.name.should equal(:master)
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @master.should_parse_config?.should be_true
   end
 
   it "should declare a main command" do
     @master.should respond_to(:main)
   end
 
   it "should declare a parseonly command" do
     @master.should respond_to(:parseonly)
   end
 
   it "should declare a compile command" do
     @master.should respond_to(:compile)
   end
 
   it "should declare a preinit block" do
     @master.should respond_to(:preinit)
   end
 
   describe "during preinit" do
     before :each do
       @master.stubs(:trap)
     end
 
     it "should catch INT" do
       @master.stubs(:trap).with { |arg,block| arg == :INT }
 
       @master.preinit
     end
 
     it "should create a Puppet Daemon" do
       Puppet::Daemon.expects(:new).returns(@daemon)
 
       @master.preinit
     end
 
     it "should give ARGV to the Daemon" do
       argv = stub 'argv'
       ARGV.stubs(:dup).returns(argv)
       @daemon.expects(:argv=).with(argv)
 
       @master.preinit
     end
 
   end
 
   [:debug,:verbose].each do |option|
     it "should declare handle_#{option} method" do
       @master.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @master.options.expects(:[]=).with(option, 'arg')
       @master.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   describe "when applying options" do
     before do
       @master.command_line.stubs(:args).returns([])
     end
 
     it "should set the log destination with --logdest" do
       Puppet::Log.expects(:newdestination).with("console")
 
       @master.handle_logdest("console")
     end
 
     it "should put the setdest options to true" do
       @master.options.expects(:[]=).with(:setdest,true)
 
       @master.handle_logdest("console")
     end
 
     it "should parse the log destination from ARGV" do
       @master.command_line.stubs(:args).returns(%w{--logdest /my/file})
 
       Puppet::Util::Log.expects(:newdestination).with("/my/file")
 
       @master.parse_options
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
       Puppet::Log.stubs(:level=)
       Puppet::SSL::CertificateAuthority.stubs(:instance)
       Puppet::SSL::CertificateAuthority.stubs(:ca?)
       Puppet.settings.stubs(:use)
 
       @master.options.stubs(:[]).with(any_parameters)
     end
 
     it "should set log level to debug if --debug was passed" do
       @master.options.stubs(:[]).with(:debug).returns(true)
 
       Puppet::Log.expects(:level=).with(:debug)
 
       @master.setup
     end
 
     it "should set log level to info if --verbose was passed" do
       @master.options.stubs(:[]).with(:verbose).returns(true)
 
       Puppet::Log.expects(:level=).with(:info)
 
       @master.setup
     end
 
     it "should set console as the log destination if no --logdest and --daemonize" do
       @master.stubs(:[]).with(:daemonize).returns(:false)
 
       Puppet::Log.expects(:newdestination).with(:syslog)
 
       @master.setup
     end
 
     it "should set syslog as the log destination if no --logdest and not --daemonize" do
       Puppet::Log.expects(:newdestination).with(:syslog)
 
       @master.setup
     end
 
     it "should set syslog as the log destination if --rack" do
       @master.options.stubs(:[]).with(:rack).returns(:true)
 
       Puppet::Log.expects(:newdestination).with(:syslog)
 
       @master.setup
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @master.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @master.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @master.setup }.should raise_error(SystemExit)
     end
 
     it "should tell Puppet.settings to use :main,:ssl and :master category" do
       Puppet.settings.expects(:use).with(:main,:master,:ssl)
 
       @master.setup
     end
 
     it "should cache class in yaml" do
       Puppet::Node.expects(:cache_class=).with(:yaml)
 
       @master.setup
     end
 
     describe "with no ca" do
 
       it "should set the ca_location to none" do
         Puppet::SSL::Host.expects(:ca_location=).with(:none)
 
         @master.setup
       end
 
     end
 
     describe "with a ca configured" do
 
       before :each do
         Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
       end
 
       it "should set the ca_location to local" do
         Puppet::SSL::Host.expects(:ca_location=).with(:local)
 
         @master.setup
       end
 
       it "should tell Puppet.settings to use :ca category" do
         Puppet.settings.expects(:use).with(:ca)
 
         @master.setup
       end
 
       it "should instantiate the CertificateAuthority singleton" do
         Puppet::SSL::CertificateAuthority.expects(:instance)
 
         @master.setup
       end
 
 
     end
 
   end
 
   describe "when running" do
     before do
       @master.preinit
     end
 
     it "should dispatch to parseonly if parseonly is set" do
       Puppet.stubs(:[]).with(:parseonly).returns(true)
       @master.options[:node] = nil
 
       @master.expects(:parseonly)
       @master.run_command
     end
 
     it "should dispatch to compile if called with --compile" do
       @master.options[:node] = "foo"
       @master.expects(:compile)
       @master.run_command
     end
 
     it "should dispatch to main if parseonly is not set" do
       Puppet.stubs(:[]).with(:parseonly).returns(false)
       @master.options[:node] = nil
 
       @master.expects(:main)
       @master.run_command
     end
 
 
     describe "the parseonly command" do
       before :each do
         Puppet.stubs(:[]).with(:environment)
         Puppet.stubs(:[]).with(:manifest).returns("site.pp")
         Puppet.stubs(:err)
         @master.stubs(:exit)
         @collection = stub_everything
         Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
       end
 
       it "should use a Puppet Resource Type Collection to parse the file" do
         @collection.expects(:perform_initial_import)
         @master.parseonly
       end
 
       it "should exit with exit code 0 if no error" do
         @master.expects(:exit).with(0)
         @master.parseonly
       end
 
       it "should exit with exit code 1 if error" do
         @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
         @master.expects(:exit).with(1)
         @master.parseonly
       end
     end
 
     describe "the compile command" do
       before do
         Puppet.stubs(:[]).with(:environment)
         Puppet.stubs(:[]).with(:manifest).returns("site.pp")
         Puppet.stubs(:err)
         @master.stubs(:jj)
         @master.stubs(:exit)
         Puppet.features.stubs(:pson?).returns true
       end
 
       it "should fail if pson isn't available" do
         Puppet.features.expects(:pson?).returns false
         lambda { @master.compile }.should raise_error
       end
 
       it "should compile a catalog for the specified node" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.expects(:find).with("foo").returns Puppet::Resource::Catalog.new
         $stdout.stubs(:puts)
 
         @master.compile
       end
 
       it "should convert the catalog to a pure-resource catalog and use 'jj' to pretty-print the catalog" do
         catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog.expects(:find).returns catalog
 
         catalog.expects(:to_resource).returns("rescat")
 
         @master.options[:node] = "foo"
         @master.expects(:jj).with("rescat")
 
         @master.compile
       end
 
       it "should exit with error code 30 if no catalog can be found" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.expects(:find).returns nil
         @master.expects(:exit).with(30)
         $stderr.expects(:puts)
 
         @master.compile
       end
 
       it "should exit with error code 30 if there's a failure" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.expects(:find).raises ArgumentError
         @master.expects(:exit).with(30)
         $stderr.expects(:puts)
 
         @master.compile
       end
     end
 
     describe "the main command" do
       before :each do
         @master.preinit
         @server = stub_everything 'server'
         Puppet::Network::Server.stubs(:new).returns(@server)
         @app = stub_everything 'app'
         Puppet::SSL::Host.stubs(:localhost)
         Puppet::SSL::CertificateAuthority.stubs(:ca?)
         Process.stubs(:uid).returns(1000)
         Puppet.stubs(:service)
         Puppet.stubs(:[])
         Puppet.stubs(:notice)
         Puppet.stubs(:start)
       end
 
       it "should create a Server" do
         Puppet::Network::Server.expects(:new)
 
         @master.main
       end
 
       it "should give the server to the daemon" do
         @daemon.expects(:server=).with(@server)
 
         @master.main
       end
 
       it "should create the server with the right XMLRPC handlers" do
         Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:Status, :FileServer, :Master, :Report, :Filebucket]}
 
         @master.main
       end
 
       it "should create the server with a :ca xmlrpc handler if needed" do
         Puppet.stubs(:[]).with(:ca).returns(true)
         Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers].include?(:CA) }
 
         @master.main
       end
 
       it "should generate a SSL cert for localhost" do
         Puppet::SSL::Host.expects(:localhost)
 
         @master.main
       end
 
       it "should make sure to *only* hit the CA for data" do
         Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
 
         Puppet::SSL::Host.expects(:ca_location=).with(:only)
 
         @master.main
       end
 
       it "should drop privileges if running as root" do
         Puppet.features.stubs(:root?).returns true
 
         Puppet::Util.expects(:chuser)
 
         @master.main
       end
 
       it "should daemonize if needed" do
         Puppet.stubs(:[]).with(:daemonize).returns(true)
 
         @daemon.expects(:daemonize)
 
         @master.main
       end
 
       it "should start the service" do
         @daemon.expects(:start)
 
         @master.main
       end
 
-      describe "with --rack" do
-        confine "Rack is not available" => Puppet.features.rack?
-
+      describe "with --rack", :if => Puppet.features.rack? do
         before do
           require 'puppet/network/http/rack'
           Puppet::Network::HTTP::Rack.stubs(:new).returns(@app)
         end
 
         it "it should create the app with REST and XMLRPC support" do
           @master.options.stubs(:[]).with(:rack).returns(:true)
 
           Puppet::Network::HTTP::Rack.expects(:new).with { |args|
             args[:xmlrpc_handlers] == [:Status, :FileServer, :Master, :Report, :Filebucket] and
             args[:protocols] == [:rest, :xmlrpc]
           }
 
           @master.main
         end
 
         it "it should not start a daemon" do
           @master.options.stubs(:[]).with(:rack).returns(:true)
 
           @daemon.expects(:start).never
 
           @master.main
         end
 
         it "it should return the app" do
           @master.options.stubs(:[]).with(:rack).returns(:true)
 
           app = @master.main
           app.should equal(@app)
         end
 
       end
 
     end
   end
 end
diff --git a/spec/unit/application_spec.rb b/spec/unit/application_spec.rb
index be7cda340..f68a7e209 100755
--- a/spec/unit/application_spec.rb
+++ b/spec/unit/application_spec.rb
@@ -1,512 +1,509 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/application'
 require 'puppet'
 require 'getoptlong'
 
 describe Puppet::Application do
 
   before do
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
     # avoid actually trying to parse any settings
     Puppet.settings.stubs(:parse)
   end
 
   describe ".run_mode" do
     it "should default to user" do
       @appclass.run_mode.name.should == :user
     end
 
     it "should set and get a value" do
       @appclass.run_mode :agent
       @appclass.run_mode.name.should == :agent
     end
   end
 
   it "should have a run entry-point" do
     @app.should respond_to(:run)
   end
 
   it "should have a read accessor to options" do
     @app.should respond_to(:options)
   end
 
   it "should include a default setup method" do
     @app.should respond_to(:setup)
   end
 
   it "should include a default preinit method" do
     @app.should respond_to(:preinit)
   end
 
   it "should include a default run_command method" do
     @app.should respond_to(:run_command)
   end
 
   it "should invoke main as the default" do
     @app.expects( :main )
     @app.run_command
   end
 
   describe 'when invoking clear!' do
     before :each do
       Puppet::Application.run_status = :stop_requested
       Puppet::Application.clear!
     end
 
     it 'should have nil run_status' do
       Puppet::Application.run_status.should be_nil
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return false for interrupted?' do
       Puppet::Application.interrupted?.should be_false
     end
 
     it 'should return true for clear?' do
       Puppet::Application.clear?.should be_true
     end
   end
 
   describe 'after invoking stop!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.stop!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :stop_requested' do
       Puppet::Application.run_status.should == :stop_requested
     end
 
     it 'should return true for stop_requested?' do
       Puppet::Application.stop_requested?.should be_true
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when invoking restart!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.restart!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :restart_requested' do
       Puppet::Application.run_status.should == :restart_requested
     end
 
     it 'should return true for restart_requested?' do
       Puppet::Application.restart_requested?.should be_true
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when performing a controlled_run' do
     it 'should not execute block if not :clear?' do
       Puppet::Application.run_status = :stop_requested
       target = mock 'target'
       target.expects(:some_method).never
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     it 'should execute block if :clear?' do
       Puppet::Application.run_status = nil
       target = mock 'target'
       target.expects(:some_method).once
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
-    describe 'on POSIX systems' do
-      confine "HUP works only on POSIX systems" => Puppet.features.posix?
-
+    describe 'on POSIX systems', :if => Puppet.features.posix? do
       it 'should signal process with HUP after block if restart requested during block execution' do
         Puppet::Application.run_status = nil
         target = mock 'target'
         target.expects(:some_method).once
         old_handler = trap('HUP') { target.some_method }
         begin
           Puppet::Application.controlled_run do
             Puppet::Application.run_status = :restart_requested
           end
         ensure
           trap('HUP', old_handler)
         end
       end
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
   end
 
   describe "when parsing command-line options" do
 
     before :each do
       @app.command_line.stubs(:args).returns([])
 
       Puppet.settings.stubs(:optparse_addargs).returns([])
     end
 
     it "should pass the banner to the option parser" do
       option_parser = stub "option parser"
       option_parser.stubs(:on)
       option_parser.stubs(:parse!)
       @app.class.instance_eval do
         banner "banner"
       end
 
       OptionParser.expects(:new).with("banner").returns(option_parser)
 
       @app.parse_options
     end
 
     it "should get options from Puppet.settings.optparse_addargs" do
       Puppet.settings.expects(:optparse_addargs).returns([])
 
       @app.parse_options
     end
 
     it "should add Puppet.settings options to OptionParser" do
       Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option"]])
       Puppet.settings.expects(:handlearg).with("--option", 'true')
       @app.command_line.stubs(:args).returns(["--option"])
       @app.parse_options
     end
 
     it "should ask OptionParser to parse the command-line argument" do
       @app.command_line.stubs(:args).returns(%w{ fake args })
       OptionParser.any_instance.expects(:parse!).with(%w{ fake args })
 
       @app.parse_options
     end
 
-    describe "when using --help" do
-      confine "rdoc" => Puppet.features.usage?
+    describe "when using --help", :if => Puppet.features.usage? do
 
       it "should call RDoc::usage and exit" do
         @app.expects(:exit)
         RDoc.expects(:usage).returns(true)
 
         @app.handle_help(nil)
       end
 
     end
 
     describe "when using --version" do
       it "should declare a version option" do
         @app.should respond_to(:handle_version)
       end
 
       it "should exit after printing the version" do
         @app.stubs(:puts)
 
         lambda { @app.handle_version(nil) }.should raise_error(SystemExit)
       end
     end
 
     describe "when dealing with an argument not declared directly by the application" do
       it "should pass it to handle_unknown if this method exists" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled", :REQUIRED]])
 
         @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
         @app.command_line.stubs(:args).returns(["--not-handled", "value"])
         @app.parse_options
       end
 
       it "should pass it to Puppet.settings if handle_unknown says so" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
 
         @app.stubs(:handle_unknown).with("--topuppet", "value").returns(false)
 
         Puppet.settings.expects(:handlearg).with("--topuppet", "value")
         @app.command_line.stubs(:args).returns(["--topuppet", "value"])
         @app.parse_options
       end
 
       it "should pass it to Puppet.settings if there is no handle_unknown method" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
 
         @app.stubs(:respond_to?).returns(false)
 
         Puppet.settings.expects(:handlearg).with("--topuppet", "value")
         @app.command_line.stubs(:args).returns(["--topuppet", "value"])
         @app.parse_options
       end
 
       it "should transform boolean false value to string for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "false")
         @app.handlearg("--option", false)
       end
 
       it "should transform boolean true value to string for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "true")
         @app.handlearg("--option", true)
       end
 
       it "should transform boolean option to normal form for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "true")
         @app.handlearg("--[no-]option", true)
       end
 
       it "should transform boolean option to no- form for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--no-option", "false")
         @app.handlearg("--[no-]option", false)
       end
 
     end
 
     it "should exit if OptionParser raises an error" do
       $stderr.stubs(:puts)
       OptionParser.any_instance.stubs(:parse!).raises(OptionParser::ParseError.new("blah blah"))
 
       @app.expects(:exit)
 
       lambda { @app.parse_options }.should_not raise_error
     end
 
   end
 
   describe "when calling default setup" do
 
     before :each do
       @app.stubs(:should_parse_config?).returns(false)
       @app.options.stubs(:[])
     end
 
     [ :debug, :verbose ].each do |level|
       it "should honor option #{level}" do
         @app.options.stubs(:[]).with(level).returns(true)
         Puppet::Util::Log.stubs(:newdestination)
 
         Puppet::Util::Log.expects(:level=).with(level == :verbose ? :info : :debug)
 
         @app.setup
       end
     end
 
     it "should honor setdest option" do
       @app.options.stubs(:[]).with(:setdest).returns(false)
 
       Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
       @app.setup
     end
 
   end
 
   describe "when running" do
 
     before :each do
       @app.stubs(:preinit)
       @app.stubs(:setup)
       @app.stubs(:parse_options)
     end
 
     it "should call preinit" do
       @app.stubs(:run_command)
 
       @app.expects(:preinit)
 
       @app.run
     end
 
     it "should call parse_options" do
       @app.stubs(:run_command)
 
       @app.expects(:parse_options)
 
       @app.run
     end
 
     it "should call run_command" do
 
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should parse Puppet configuration if should_parse_config is called" do
       @app.stubs(:run_command)
       @app.class.should_parse_config
 
       Puppet.settings.expects(:parse)
 
       @app.run
     end
 
     it "should not parse_option if should_not_parse_config is called" do
       @app.stubs(:run_command)
       @app.class.should_not_parse_config
 
       Puppet.settings.expects(:parse).never
 
       @app.run
     end
 
     it "should parse Puppet configuration if needed" do
       @app.stubs(:run_command)
       @app.stubs(:should_parse_config?).returns(true)
 
       Puppet.settings.expects(:parse)
 
       @app.run
     end
 
     it "should call run_command" do
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should call main as the default command" do
       @app.expects(:main)
 
       @app.run
     end
 
     it "should warn and exit if no command can be called" do
       $stderr.expects(:puts)
       @app.expects(:exit).with(1)
       @app.run
     end
 
     it "should raise an error if dispatch returns no command" do
       @app.stubs(:get_command).returns(nil)
       $stderr.expects(:puts)
       @app.expects(:exit).with(1)
       @app.run
     end
 
     it "should raise an error if dispatch returns an invalid command" do
       @app.stubs(:get_command).returns(:this_function_doesnt_exist)
       $stderr.expects(:puts)
       @app.expects(:exit).with(1)
       @app.run
     end
   end
 
   describe "when metaprogramming" do
 
     describe "when calling option" do
       it "should create a new method named after the option" do
         @app.class.option("--test1","-t") do
         end
 
         @app.should respond_to(:handle_test1)
       end
 
       it "should transpose in option name any '-' into '_'" do
         @app.class.option("--test-dashes-again","-t") do
         end
 
         @app.should respond_to(:handle_test_dashes_again)
       end
 
       it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
         @app.class.option("--[no-]test2","-t") do
         end
 
         @app.should respond_to(:handle_test2)
       end
 
       describe "when a block is passed" do
         it "should create a new method with it" do
           @app.class.option("--[no-]test2","-t") do
             raise "I can't believe it, it works!"
           end
 
           lambda { @app.handle_test2 }.should raise_error
         end
 
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
 
           @app.class.option("--[no-]test3","-t") do
           end
 
           @app.parse_options
         end
 
         it "should pass a block that calls our defined method" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with('--test4','-t').yields(nil)
 
           @app.expects(:send).with(:handle_test4, nil)
 
           @app.class.option("--test4","-t") do
           end
 
           @app.parse_options
         end
       end
 
       describe "when no block is given" do
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with("--test4","-t")
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
 
         it "should give to OptionParser a block that adds the the value to the options array" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
 
           @app.options.expects(:[]=).with(:test4,nil)
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
       end
     end
 
   end
 end
diff --git a/spec/unit/file_serving/metadata_spec.rb b/spec/unit/file_serving/metadata_spec.rb
index aa0dcd511..dd40324bc 100755
--- a/spec/unit/file_serving/metadata_spec.rb
+++ b/spec/unit/file_serving/metadata_spec.rb
@@ -1,286 +1,286 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/file_serving/metadata'
 
 describe Puppet::FileServing::Metadata do
   it "should should be a subclass of Base" do
     Puppet::FileServing::Metadata.superclass.should equal(Puppet::FileServing::Base)
   end
 
   it "should indirect file_metadata" do
     Puppet::FileServing::Metadata.indirection.name.should == :file_metadata
   end
 
   it "should should include the IndirectionHooks module in its indirection" do
     Puppet::FileServing::Metadata.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
   end
 
   it "should have a method that triggers attribute collection" do
     Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:collect)
   end
 
   it "should support pson serialization" do
     Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson)
   end
 
   it "should support to_pson_data_hash" do
     Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson_data_hash)
   end
 
   it "should support pson deserialization" do
     Puppet::FileServing::Metadata.should respond_to(:from_pson)
   end
 
   describe "when serializing" do
     before do
       @metadata = Puppet::FileServing::Metadata.new("/foo/bar")
     end
     it "should perform pson serialization by calling to_pson on it's pson_data_hash" do
       pdh = mock "data hash"
       pdh_as_pson = mock "data as pson"
       @metadata.expects(:to_pson_data_hash).returns pdh
       pdh.expects(:to_pson).returns pdh_as_pson
       @metadata.to_pson.should == pdh_as_pson
     end
 
     it "should serialize as FileMetadata" do
       @metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
     end
 
     it "the data should include the path, relative_path, links, owner, group, mode, checksum, type, and destination" do
       @metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
     end
 
     it "should pass the path in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['path'] == @metadata.path
     end
 
     it "should pass the relative_path in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['relative_path'] == @metadata.relative_path
     end
 
     it "should pass the links in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['links'] == @metadata.links
     end
 
     it "should pass the path owner in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['owner'] == @metadata.owner
     end
 
     it "should pass the group in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['group'] == @metadata.group
     end
 
     it "should pass the mode in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['mode'] == @metadata.mode
     end
 
     it "should pass the ftype in the hash verbatum as the 'type'" do
       @metadata.to_pson_data_hash['data']['type'] == @metadata.ftype
     end
 
     it "should pass the destination verbatum" do
       @metadata.to_pson_data_hash['data']['destination'] == @metadata.destination
     end
 
     it "should pass the checksum in the hash as a nested hash" do
       @metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
     end
 
     it "should pass the checksum_type in the hash verbatum as the checksum's type" do
       @metadata.to_pson_data_hash['data']['checksum']['type'] == @metadata.checksum_type
     end
 
     it "should pass the checksum in the hash verbatum as the checksum's value" do
       @metadata.to_pson_data_hash['data']['checksum']['value'] == @metadata.checksum
     end
 
   end
 end
 
 describe Puppet::FileServing::Metadata, " when finding the file to use for setting attributes" do
   before do
     @path = "/my/path"
     @metadata = Puppet::FileServing::Metadata.new(@path)
 
     # Use a link because it's easier to test -- no checksumming
     @stat = stub "stat", :uid => 10, :gid => 20, :mode => 0755, :ftype => "link"
 
     # Not quite.  We don't want to checksum links, but we must because they might be being followed.
     @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
     @metadata.stubs(:md5_file).returns(@checksum)           #
   end
 
   it "should accept a base path path to which the file should be relative" do
     File.expects(:lstat).with(@path).returns @stat
     File.expects(:readlink).with(@path).returns "/what/ever"
     @metadata.collect
   end
 
   it "should use the set base path if one is not provided" do
     File.expects(:lstat).with(@path).returns @stat
     File.expects(:readlink).with(@path).returns "/what/ever"
     @metadata.collect
   end
 
   it "should raise an exception if the file does not exist" do
     File.expects(:lstat).with(@path).raises(Errno::ENOENT)
     proc { @metadata.collect}.should raise_error(Errno::ENOENT)
   end
 end
 
 describe Puppet::FileServing::Metadata, " when collecting attributes" do
   before do
     @path = "/my/file"
     # Use a real file mode, so we can validate the masking is done.
     @stat = stub 'stat', :uid => 10, :gid => 20, :mode => 33261, :ftype => "file"
     File.stubs(:lstat).returns(@stat)
     @checksum = Digest::MD5.hexdigest("some content\n")
     @metadata = Puppet::FileServing::Metadata.new("/my/file")
     @metadata.stubs(:md5_file).returns(@checksum)
     @metadata.collect
   end
 
   it "should be able to produce xmlrpc-style attribute information" do
     @metadata.should respond_to(:attributes_with_tabs)
   end
 
   # LAK:FIXME This should actually change at some point
   it "should set the owner by id" do
     @metadata.owner.should be_instance_of(Fixnum)
   end
 
   # LAK:FIXME This should actually change at some point
   it "should set the group by id" do
     @metadata.group.should be_instance_of(Fixnum)
   end
 
   it "should set the owner to the file's current owner" do
     @metadata.owner.should == 10
   end
 
   it "should set the group to the file's current group" do
     @metadata.group.should == 20
   end
 
   it "should set the mode to the file's masked mode" do
     @metadata.mode.should == 0755
   end
 
   it "should set the checksum to the file's current checksum" do
     @metadata.checksum.should == "{md5}#{@checksum}"
   end
 
   describe "when managing files" do
     it "should default to a checksum of type MD5" do
       @metadata.checksum.should == "{md5}#{@checksum}"
     end
 
     it "should give a mtime checksum when checksum_type is set" do
       time = Time.now
       @metadata.checksum_type = "mtime"
       @metadata.expects(:mtime_file).returns(@time)
       @metadata.collect
       @metadata.checksum.should == "{mtime}#{@time}"
     end
 
     it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
       @metadata.attributes_with_tabs.should == "#{0755.to_s}\tfile\t10\t20\t{md5}#{@checksum}"
     end
   end
 
   describe "when managing directories" do
     before do
       @stat.stubs(:ftype).returns("directory")
       @time = Time.now
       @metadata.expects(:ctime_file).returns(@time)
     end
 
     it "should only use checksums of type 'ctime' for directories" do
       @metadata.collect
       @metadata.checksum.should == "{ctime}#{@time}"
     end
 
     it "should only use checksums of type 'ctime' for directories even if checksum_type set" do
       @metadata.checksum_type = "mtime"
       @metadata.expects(:mtime_file).never
       @metadata.collect
       @metadata.checksum.should == "{ctime}#{@time}"
     end
 
     it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
       @metadata.collect
       @metadata.attributes_with_tabs.should == "#{0755.to_s}\tdirectory\t10\t20\t{ctime}#{@time.to_s}"
     end
   end
 
   describe "when managing links" do
     before do
       @stat.stubs(:ftype).returns("link")
       File.expects(:readlink).with("/my/file").returns("/path/to/link")
       @metadata.collect
 
       @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
       @file.stubs(:md5_file).returns(@checksum)           #
     end
 
     it "should read links instead of returning their checksums" do
       @metadata.destination.should == "/path/to/link"
     end
 
-    it "should produce tab-separated mode, type, owner, group, and destination for xmlrpc" do
-      pending "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
+    pending "should produce tab-separated mode, type, owner, group, and destination for xmlrpc" do
+      # "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
       @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t/path/to/link"
     end
 
     it "should produce tab-separated mode, type, owner, group, checksum, and destination for xmlrpc" do
       @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t{md5}eb9c2bf0eb63f3a7bc0ea37ef18aeba5\t/path/to/link"
     end
   end
 end
 
 describe Puppet::FileServing::Metadata, " when pointing to a link" do
   describe "when links are managed" do
     before do
       @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :manage)
       File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
       File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
 
       @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
       @file.stubs(:md5_file).returns(@checksum)           #
     end
     it "should store the destination of the link in :destination if links are :manage" do
       @file.collect
       @file.destination.should == "/some/other/path"
     end
-    it "should not collect the checksum if links are :manage" do
-      pending "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
+    pending "should not collect the checksum if links are :manage" do
+      # We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow.
       @file.collect
       @file.checksum.should be_nil
     end
     it "should collect the checksum if links are :manage" do # see pending note above
       @file.collect
       @file.checksum.should == "{md5}#{@checksum}"
     end
   end
 
   describe "when links are followed" do
     before do
       @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :follow)
       File.expects(:stat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
       File.expects(:readlink).with("/base/path/my/file").never
       @checksum = Digest::MD5.hexdigest("some content\n")
       @file.stubs(:md5_file).returns(@checksum)
     end
     it "should not store the destination of the link in :destination if links are :follow" do
       @file.collect
       @file.destination.should be_nil
     end
     it "should collect the checksum if links are :follow" do
       @file.collect
       @file.checksum.should == "{md5}#{@checksum}"
     end
   end
 end
diff --git a/spec/unit/indirector/catalog/active_record_spec.rb b/spec/unit/indirector/catalog/active_record_spec.rb
index ba8f1dad9..a368fb3a6 100755
--- a/spec/unit/indirector/catalog/active_record_spec.rb
+++ b/spec/unit/indirector/catalog/active_record_spec.rb
@@ -1,159 +1,157 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 
-describe "Puppet::Resource::Catalog::ActiveRecord" do
-  confine "Missing Rails" => Puppet.features.rails?
-
+describe "Puppet::Resource::Catalog::ActiveRecord", :if => Puppet.features.rails? do
   require 'puppet/rails'
 
   before :all do
     class Tableless < ActiveRecord::Base
       def self.columns
         @columns ||= []
       end
       def self.column(name, sql_type=nil, default=nil, null=true)
         columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
       end
     end
 
     class Host < Tableless
       column :name, :string, :null => false
       column :ip, :string
       column :environment, :string
       column :last_compile, :datetime
     end
   end
 
   before do
     require 'puppet/indirector/catalog/active_record'
     Puppet.features.stubs(:rails?).returns true
     Puppet::Rails.stubs(:init)
     @terminus = Puppet::Resource::Catalog::ActiveRecord.new
   end
 
   it "should be a subclass of the ActiveRecord terminus class" do
     Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
   end
 
   it "should use Puppet::Rails::Host as its ActiveRecord model" do
     Puppet::Resource::Catalog::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
   end
 
   describe "when finding an instance" do
     before do
       @request = stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
     end
 
     # This hack is here because we don't want to look in the db unless we actually want
     # to look in the db, but our indirection architecture in 0.24.x isn't flexible
     # enough to tune that via configuration.
     it "should return nil unless ':cache_integration_hack' is set to true" do
       @request.options[:cache_integration_hack] = false
       Puppet::Rails::Host.expects(:find_by_name).never
       @terminus.find(@request).should be_nil
     end
 
     it "should use the Hosts ActiveRecord class to find the host" do
       Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
       @terminus.find(@request)
     end
 
     it "should return nil if no host instance can be found" do
       Puppet::Rails::Host.expects(:find_by_name).returns nil
 
       @terminus.find(@request).should be_nil
     end
 
     it "should return a catalog with the same name as the host if the host can be found" do
       host = stub 'host', :name => "foo", :resources => []
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       result = @terminus.find(@request)
       result.should be_instance_of(Puppet::Resource::Catalog)
       result.name.should == "foo"
     end
 
     it "should set each of the host's resources as a transportable resource within the catalog" do
       host = stub 'host', :name => "foo"
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       res1 = mock 'res1', :to_transportable => "trans_res1"
       res2 = mock 'res2', :to_transportable => "trans_res2"
 
       host.expects(:resources).returns [res1, res2]
 
       catalog = stub 'catalog'
       Puppet::Resource::Catalog.expects(:new).returns catalog
 
       catalog.expects(:add_resource).with "trans_res1"
       catalog.expects(:add_resource).with "trans_res2"
 
       @terminus.find(@request)
     end
   end
 
   describe "when saving an instance" do
     before do
       @host = Host.new(:name => "foo")
       @host.stubs(:merge_resources)
       @host.stubs(:save)
       @host.stubs(:railsmark).yields
 
       @node = Puppet::Node.new("foo", :environment => "environment")
       Puppet::Node.indirection.stubs(:find).with("foo").returns(@node)
 
       Puppet::Rails::Host.stubs(:find_by_name).returns @host
       @catalog = Puppet::Resource::Catalog.new("foo")
       @request = Puppet::Indirector::Request.new(:active_record, :save, @catalog)
     end
 
     it "should find the Rails host with the same name" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @terminus.save(@request)
     end
 
     it "should create a new Rails host if none can be found" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
 
       Puppet::Rails::Host.expects(:create).with(:name => "foo").returns @host
 
       @terminus.save(@request)
     end
 
     it "should set the catalog vertices as resources on the Rails host instance" do
       @catalog.expects(:vertices).returns "foo"
       @host.expects(:merge_resources).with("foo")
 
       @terminus.save(@request)
     end
 
     it "should set host ip if we could find a matching node" do
       @node.stubs(:parameters).returns({"ipaddress" => "192.168.0.1"})
 
       @terminus.save(@request)
       @host.ip.should == '192.168.0.1'
     end
 
     it "should set host environment if we could find a matching node" do
       @terminus.save(@request)
       @host.environment.should == "environment"
     end
 
     it "should set the last compile time on the host" do
       now = Time.now
       Time.expects(:now).returns now
 
       @terminus.save(@request)
       @host.last_compile.should == now
     end
 
     it "should save the Rails host instance" do
       @host.expects(:save)
 
       @terminus.save(@request)
     end
   end
 end
diff --git a/spec/unit/indirector/facts/active_record_spec.rb b/spec/unit/indirector/facts/active_record_spec.rb
index 0bdcfcb77..e96e01056 100755
--- a/spec/unit/indirector/facts/active_record_spec.rb
+++ b/spec/unit/indirector/facts/active_record_spec.rb
@@ -1,105 +1,103 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/rails'
 require 'puppet/node/facts'
 
-describe "Puppet::Node::Facts::ActiveRecord" do
-  confine "Missing Rails" => Puppet.features.rails?
-
+describe "Puppet::Node::Facts::ActiveRecord", :if => Puppet.features.rails? do
   before do
     require 'puppet/indirector/facts/active_record'
     Puppet.features.stubs(:rails?).returns true
     Puppet::Rails.stubs(:init)
     @terminus = Puppet::Node::Facts::ActiveRecord.new
   end
 
   it "should be a subclass of the ActiveRecord terminus class" do
     Puppet::Node::Facts::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
   end
 
   it "should use Puppet::Rails::Host as its ActiveRecord model" do
     Puppet::Node::Facts::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
   end
 
   describe "when finding an instance" do
     before do
       @request = stub 'request', :key => "foo"
     end
 
     it "should use the Hosts ActiveRecord class to find the host" do
       Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
       @terminus.find(@request)
     end
 
     it "should include the fact names and values when finding the host" do
       Puppet::Rails::Host.expects(:find_by_name).with { |key, args| args[:include] == {:fact_values => :fact_name} }
       @terminus.find(@request)
     end
 
     it "should return nil if no host instance can be found" do
       Puppet::Rails::Host.expects(:find_by_name).returns nil
 
       @terminus.find(@request).should be_nil
     end
 
     it "should convert the node's parameters into a Facts instance if a host instance is found" do
       host = stub 'host', :name => "foo"
       host.expects(:get_facts_hash).returns("one" => [mock("two_value", :value => "two")], "three" => [mock("three_value", :value => "four")])
 
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       result = @terminus.find(@request)
 
       result.should be_instance_of(Puppet::Node::Facts)
       result.name.should == "foo"
       result.values.should == {"one" => "two", "three" => "four"}
     end
 
     it "should convert all single-member arrays into non-arrays" do
       host = stub 'host', :name => "foo"
       host.expects(:get_facts_hash).returns("one" => [mock("two_value", :value => "two")])
 
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       @terminus.find(@request).values["one"].should == "two"
     end
   end
 
   describe "when saving an instance" do
     before do
       @host = stub 'host', :name => "foo", :save => nil, :merge_facts => nil
       Puppet::Rails::Host.stubs(:find_by_name).returns @host
       @facts = Puppet::Node::Facts.new("foo", "one" => "two", "three" => "four")
       @request = stub 'request', :key => "foo", :instance => @facts
     end
 
     it "should find the Rails host with the same name" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @terminus.save(@request)
     end
 
     it "should create a new Rails host if none can be found" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
 
       Puppet::Rails::Host.expects(:create).with(:name => "foo").returns @host
 
       @terminus.save(@request)
     end
 
     it "should set the facts as facts on the Rails host instance" do
       # There is other stuff added to the hash.
       @host.expects(:merge_facts).with { |args| args["one"] == "two" and args["three"] == "four" }
 
       @terminus.save(@request)
     end
 
     it "should save the Rails host instance" do
       @host.expects(:save)
 
       @terminus.save(@request)
     end
   end
 end
diff --git a/spec/unit/indirector/facts/couch_spec.rb b/spec/unit/indirector/facts/couch_spec.rb
index c0dd54b8a..e3a9d7f14 100644
--- a/spec/unit/indirector/facts/couch_spec.rb
+++ b/spec/unit/indirector/facts/couch_spec.rb
@@ -1,98 +1,97 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/node/facts'
 
-describe "Puppet::Node::Facts::Couch" do
-  confine "couchrest gem is missing; cannot test couch terminus" => Puppet.features.couchdb?
+describe "Puppet::Node::Facts::Couch", :if => Puppet.features.couchdb? do
   require 'puppet/indirector/facts/couch' if Puppet.features.couchdb?
 
   before do
     @mock_db = mock('couch db')
     mock_document = CouchRest::Document.new(:_id => fake_request.key, :facts => fake_request.values)
     mock_document.stubs(:database).returns(@mock_db)
     @mock_db.stubs(:get).with(fake_request.key).returns(mock_document)
     Puppet::Node::Facts::Couch.stubs(:db).returns(@mock_db)
   end
 
   subject { Puppet::Node::Facts::Couch }
 
   describe "#find" do
     describe "when the node document exists" do
       it "should find the request by key" do
         @mock_db.expects(:get).with(fake_request.key).returns({'_id' => fake_request.key, 'facts' => fake_request.instance.values})
         subject.new.find(fake_request).should == fake_request.instance
       end
     end
 
     describe "when the node document does not exist" do
       before do
         @mock_db.expects(:get).
           with(fake_request.key).
           raises(RestClient::ResourceNotFound)
       end
 
       it "should return nil" do
         subject.new.find(fake_request).should be_nil
       end
 
       it "should send Puppet a debug message" do
         Puppet.expects(:debug).with("No couchdb document with id: test.local")
         subject.new.find(fake_request).should be_nil
       end
 
     end
   end
 
   describe "#save" do
     describe "with options" do
       subject do
         lambda { Puppet::Node::Facts::Couch.new.save(fake_request([1])) }
       end
 
       it { should raise_error(ArgumentError, "PUT does not accept options") }
     end
 
     it "should save the json to the CouchDB database" do
       @mock_db.expects(:save_doc).at_least_once.returns({'ok' => true })
       subject.new.save(fake_request)
     end
 
     describe "when the document exists" do
       before do
         @doc = CouchRest::Document.new(:_id => fake_request.key, :facts => fake_request.instance.values)
         @mock_db.expects(:get).with(fake_request.key).returns(@doc)
       end
 
       it "saves the document" do
         @doc.expects(:save)
         subject.new.save(fake_request)
       end
 
     end
 
     describe "when the document does not exist" do
       before do
         @mock_db.expects(:get).
           with(fake_request.key).
           raises(RestClient::ResourceNotFound)
       end
 
       it "saves the document" do
         @mock_db.expects(:save_doc)
         subject.new.save(fake_request)
       end
 
     end
 
   end
 
   def fake_request(options={})
     facts = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml', 'test.local.yaml'))
     Struct.new(:instance, :key, :options).new(facts, facts.name, options)
   end
   private :fake_request
 
 end
 
diff --git a/spec/unit/indirector/indirection_spec.rb b/spec/unit/indirector/indirection_spec.rb
index b0e0f019c..1e774fb2e 100755
--- a/spec/unit/indirector/indirection_spec.rb
+++ b/spec/unit/indirector/indirection_spec.rb
@@ -1,795 +1,795 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/indirector/indirection'
 
-describe "Indirection Delegator", :shared => true do
+shared_examples_for "Indirection Delegator" do
   it "should create a request object with the appropriate method name and all of the passed arguments" do
     request = Puppet::Indirector::Request.new(:indirection, :find, "me")
 
     @indirection.expects(:request).with(@method, "mystuff", :one => :two).returns request
 
     @terminus.stubs(@method)
 
     @indirection.send(@method, "mystuff", :one => :two)
   end
 
   it "should let the :select_terminus method choose the terminus using the created request if the :select_terminus method is available" do
     # Define the method, so our respond_to? hook matches.
     class << @indirection
       def select_terminus(request)
       end
     end
 
     request = Puppet::Indirector::Request.new(:indirection, :find, "me")
 
     @indirection.stubs(:request).returns request
 
     @indirection.expects(:select_terminus).with(request).returns :test_terminus
 
     @indirection.stubs(:check_authorization)
     @terminus.expects(@method)
 
     @indirection.send(@method, "me")
   end
 
   it "should fail if the :select_terminus hook does not return a terminus name" do
     # Define the method, so our respond_to? hook matches.
     class << @indirection
       def select_terminus(request)
       end
     end
 
     request = stub 'request', :key => "me", :options => {}
 
     @indirection.stubs(:request).returns request
 
     @indirection.expects(:select_terminus).with(request).returns nil
 
     lambda { @indirection.send(@method, "me") }.should raise_error(ArgumentError)
   end
 
   it "should choose the terminus returned by the :terminus_class method if no :select_terminus method is available" do
     @indirection.expects(:terminus_class).returns :test_terminus
 
     @terminus.expects(@method)
 
     @indirection.send(@method, "me")
   end
 
   it "should let the appropriate terminus perform the lookup" do
     @terminus.expects(@method).with { |r| r.is_a?(Puppet::Indirector::Request) }
     @indirection.send(@method, "me")
   end
 end
 
-describe "Delegation Authorizer", :shared => true do
+shared_examples_for "Delegation Authorizer" do
   before do
     # So the :respond_to? turns out correctly.
     class << @terminus
       def authorized?
       end
     end
   end
 
   it "should not check authorization if a node name is not provided" do
     @terminus.expects(:authorized?).never
     @terminus.stubs(@method)
 
     # The quotes are necessary here, else it looks like a block.
     @request.stubs(:options).returns({})
     @indirection.send(@method, "/my/key")
   end
 
   it "should pass the request to the terminus's authorization method" do
     @terminus.expects(:authorized?).with { |r| r.is_a?(Puppet::Indirector::Request) }.returns(true)
     @terminus.stubs(@method)
 
     @indirection.send(@method, "/my/key", :node => "mynode")
   end
 
   it "should fail if authorization returns false" do
     @terminus.expects(:authorized?).returns(false)
     @terminus.stubs(@method)
     proc { @indirection.send(@method, "/my/key", :node => "mynode") }.should raise_error(ArgumentError)
   end
 
   it "should continue if authorization returns true" do
     @terminus.expects(:authorized?).returns(true)
     @terminus.stubs(@method)
     @indirection.send(@method, "/my/key", :node => "mynode")
   end
 end
 
 describe Puppet::Indirector::Indirection do
   after do
     Puppet::Util::Cacher.expire
   end
   describe "when initializing" do
     # (LAK) I've no idea how to test this, really.
     it "should store a reference to itself before it consumes its options" do
       proc { @indirection = Puppet::Indirector::Indirection.new(Object.new, :testingness, :not_valid_option) }.should raise_error
       Puppet::Indirector::Indirection.instance(:testingness).should be_instance_of(Puppet::Indirector::Indirection)
       Puppet::Indirector::Indirection.instance(:testingness).delete
     end
 
     it "should keep a reference to the indirecting model" do
       model = mock 'model'
       @indirection = Puppet::Indirector::Indirection.new(model, :myind)
       @indirection.model.should equal(model)
     end
 
     it "should set the name" do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :myind)
       @indirection.name.should == :myind
     end
 
     it "should require indirections to have unique names" do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       proc { Puppet::Indirector::Indirection.new(:test) }.should raise_error(ArgumentError)
     end
 
     it "should extend itself with any specified module" do
       mod = Module.new
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test, :extend => mod)
       @indirection.singleton_class.included_modules.should include(mod)
     end
 
     after do
       @indirection.delete if defined?(@indirection)
     end
   end
 
   describe "when an instance" do
     before :each do
       @terminus_class = mock 'terminus_class'
       @terminus = mock 'terminus'
       @terminus_class.stubs(:new).returns(@terminus)
       @cache = stub 'cache', :name => "mycache"
       @cache_class = mock 'cache_class'
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :cache_terminus).returns(@cache_class)
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :test_terminus).returns(@terminus_class)
 
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @indirection.terminus_class = :test_terminus
 
       @instance = stub 'instance', :expiration => nil, :expiration= => nil, :name => "whatever"
       @name = :mything
 
       #@request = stub 'instance', :key => "/my/key", :instance => @instance, :options => {}
       @request = mock 'instance'
     end
 
     it "should allow setting the ttl" do
       @indirection.ttl = 300
       @indirection.ttl.should == 300
     end
 
     it "should default to the :runinterval setting, converted to an integer, for its ttl" do
       Puppet.settings.expects(:value).returns "1800"
       @indirection.ttl.should == 1800
     end
 
     it "should calculate the current expiration by adding the TTL to the current time" do
       @indirection.stubs(:ttl).returns(100)
       now = Time.now
       Time.stubs(:now).returns now
       @indirection.expiration.should == (Time.now + 100)
     end
 
     it "should have a method for creating an indirection request instance" do
       @indirection.should respond_to(:request)
     end
 
     describe "creates a request" do
       it "should create it with its name as the request's indirection name" do
         Puppet::Indirector::Request.expects(:new).with { |name, *other| @indirection.name == name }
         @indirection.request(:funtest, "yayness")
       end
 
       it "should require a method and key" do
         Puppet::Indirector::Request.expects(:new).with { |name, method, key, *other| method == :funtest and key == "yayness" }
         @indirection.request(:funtest, "yayness")
       end
 
       it "should support optional arguments" do
         Puppet::Indirector::Request.expects(:new).with { |name, method, key, other| other == {:one => :two} }
         @indirection.request(:funtest, "yayness", :one => :two)
       end
 
       it "should not pass options if none are supplied" do
         Puppet::Indirector::Request.expects(:new).with { |*args| args.length < 4 }
         @indirection.request(:funtest, "yayness")
       end
 
       it "should return the request" do
         request = mock 'request'
         Puppet::Indirector::Request.expects(:new).returns request
         @indirection.request(:funtest, "yayness").should equal(request)
       end
     end
 
     describe "and looking for a model instance" do
       before { @method = :find }
 
       it_should_behave_like "Indirection Delegator"
       it_should_behave_like "Delegation Authorizer"
 
       it "should return the results of the delegation" do
         @terminus.expects(:find).returns(@instance)
         @indirection.find("me").should equal(@instance)
       end
 
       it "should set the expiration date on any instances without one set" do
         @terminus.stubs(:find).returns(@instance)
 
         @indirection.expects(:expiration).returns :yay
 
         @instance.expects(:expiration).returns(nil)
         @instance.expects(:expiration=).with(:yay)
 
         @indirection.find("/my/key")
       end
 
       it "should not override an already-set expiration date on returned instances" do
         @terminus.stubs(:find).returns(@instance)
 
         @indirection.expects(:expiration).never
 
         @instance.expects(:expiration).returns(:yay)
         @instance.expects(:expiration=).never
 
         @indirection.find("/my/key")
       end
 
       it "should filter the result instance if the terminus supports it" do
         @terminus.stubs(:find).returns(@instance)
         @terminus.stubs(:respond_to?).with(:filter).returns(true)
 
         @terminus.expects(:filter).with(@instance)
 
         @indirection.find("/my/key")
       end
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.stubs(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
         end
 
         it "should first look in the cache for an instance" do
           @terminus.stubs(:find).never
           @cache.expects(:find).returns @instance
 
           @indirection.find("/my/key")
         end
 
         it "should not look in the cache if the request specifies not to use the cache" do
           @terminus.expects(:find).returns @instance
           @cache.expects(:find).never
           @cache.stubs(:save)
 
           @indirection.find("/my/key", :ignore_cache => true)
         end
 
         it "should still save to the cache even if the cache is being ignored during readin" do
           @terminus.expects(:find).returns @instance
           @cache.expects(:save)
 
           @indirection.find("/my/key", :ignore_cache => true)
         end
 
         it "should only look in the cache if the request specifies not to use the terminus" do
           @terminus.expects(:find).never
           @cache.expects(:find)
 
           @indirection.find("/my/key", :ignore_terminus => true)
         end
 
         it "should use a request to look in the cache for cached objects" do
           @cache.expects(:find).with { |r| r.method == :find and r.key == "/my/key" }.returns @instance
 
           @cache.stubs(:save)
 
           @indirection.find("/my/key")
         end
 
         it "should return the cached object if it is not expired" do
           @instance.stubs(:expired?).returns false
 
           @cache.stubs(:find).returns @instance
           @indirection.find("/my/key").should equal(@instance)
         end
 
         it "should not fail if the cache fails" do
           @terminus.stubs(:find).returns @instance
 
           @cache.expects(:find).raises ArgumentError
           @cache.stubs(:save)
           lambda { @indirection.find("/my/key") }.should_not raise_error
         end
 
         it "should look in the main terminus if the cache fails" do
           @terminus.expects(:find).returns @instance
           @cache.expects(:find).raises ArgumentError
           @cache.stubs(:save)
           @indirection.find("/my/key").should equal(@instance)
         end
 
         it "should send a debug log if it is using the cached object" do
           Puppet.expects(:debug)
           @cache.stubs(:find).returns @instance
 
           @indirection.find("/my/key")
         end
 
         it "should not return the cached object if it is expired" do
           @instance.stubs(:expired?).returns true
 
           @cache.stubs(:find).returns @instance
           @terminus.stubs(:find).returns nil
           @indirection.find("/my/key").should be_nil
         end
 
         it "should send an info log if it is using the cached object" do
           Puppet.expects(:info)
           @instance.stubs(:expired?).returns true
 
           @cache.stubs(:find).returns @instance
           @terminus.stubs(:find).returns nil
           @indirection.find("/my/key")
         end
 
         it "should cache any objects not retrieved from the cache" do
           @cache.expects(:find).returns nil
 
           @terminus.expects(:find).returns(@instance)
           @cache.expects(:save)
 
           @indirection.find("/my/key")
         end
 
         it "should use a request to look in the cache for cached objects" do
           @cache.expects(:find).with { |r| r.method == :find and r.key == "/my/key" }.returns nil
 
           @terminus.stubs(:find).returns(@instance)
           @cache.stubs(:save)
 
           @indirection.find("/my/key")
         end
 
         it "should cache the instance using a request with the instance set to the cached object" do
           @cache.stubs(:find).returns nil
 
           @terminus.stubs(:find).returns(@instance)
 
           @cache.expects(:save).with { |r| r.method == :save and r.instance == @instance }
 
           @indirection.find("/my/key")
         end
 
         it "should send an info log that the object is being cached" do
           @cache.stubs(:find).returns nil
 
           @terminus.stubs(:find).returns(@instance)
           @cache.stubs(:save)
 
           Puppet.expects(:info)
 
           @indirection.find("/my/key")
         end
       end
     end
 
     describe "and storing a model instance" do
       before { @method = :save }
 
       it_should_behave_like "Indirection Delegator"
       it_should_behave_like "Delegation Authorizer"
 
       it "should return the result of the save" do
         @terminus.stubs(:save).returns "foo"
         @indirection.save(@instance).should == "foo"
       end
 
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.stubs(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
         end
 
         it "should return the result of saving to the terminus" do
           request = stub 'request', :instance => @instance, :node => nil
 
           @indirection.expects(:request).returns request
 
           @cache.stubs(:save)
           @terminus.stubs(:save).returns @instance
           @indirection.save(@instance).should equal(@instance)
         end
 
         it "should use a request to save the object to the cache" do
           request = stub 'request', :instance => @instance, :node => nil
 
           @indirection.expects(:request).returns request
 
           @cache.expects(:save).with(request)
           @terminus.stubs(:save)
           @indirection.save(@instance)
         end
 
         it "should not save to the cache if the normal save fails" do
           request = stub 'request', :instance => @instance, :node => nil
 
           @indirection.expects(:request).returns request
 
           @cache.expects(:save).never
           @terminus.expects(:save).raises "eh"
           lambda { @indirection.save(@instance) }.should raise_error
         end
       end
     end
 
     describe "and removing a model instance" do
       before { @method = :destroy }
 
       it_should_behave_like "Indirection Delegator"
       it_should_behave_like "Delegation Authorizer"
 
       it "should return the result of removing the instance" do
         @terminus.stubs(:destroy).returns "yayness"
         @indirection.destroy("/my/key").should == "yayness"
       end
 
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.expects(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
         end
 
         it "should use a request instance to search in and remove objects from the cache" do
           destroy = stub 'destroy_request', :key => "/my/key", :node => nil
           find = stub 'destroy_request', :key => "/my/key", :node => nil
 
           @indirection.expects(:request).with(:destroy, "/my/key").returns destroy
           @indirection.expects(:request).with(:find, "/my/key").returns find
 
           cached = mock 'cache'
 
           @cache.expects(:find).with(find).returns cached
           @cache.expects(:destroy).with(destroy)
 
           @terminus.stubs(:destroy)
 
           @indirection.destroy("/my/key")
         end
       end
     end
 
     describe "and searching for multiple model instances" do
       before { @method = :search }
 
       it_should_behave_like "Indirection Delegator"
       it_should_behave_like "Delegation Authorizer"
 
       it "should set the expiration date on any instances without one set" do
         @terminus.stubs(:search).returns([@instance])
 
         @indirection.expects(:expiration).returns :yay
 
         @instance.expects(:expiration).returns(nil)
         @instance.expects(:expiration=).with(:yay)
 
         @indirection.search("/my/key")
       end
 
       it "should not override an already-set expiration date on returned instances" do
         @terminus.stubs(:search).returns([@instance])
 
         @indirection.expects(:expiration).never
 
         @instance.expects(:expiration).returns(:yay)
         @instance.expects(:expiration=).never
 
         @indirection.search("/my/key")
       end
 
       it "should return the results of searching in the terminus" do
         @terminus.expects(:search).returns([@instance])
         @indirection.search("/my/key").should == [@instance]
       end
     end
 
     describe "and expiring a model instance" do
       describe "when caching is not enabled" do
         it "should do nothing" do
           @cache_class.expects(:new).never
 
           @indirection.expire("/my/key")
         end
       end
 
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.expects(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
 
           @cached = stub 'cached', :expiration= => nil, :name => "/my/key"
         end
 
         it "should use a request to find within the cache" do
           @cache.expects(:find).with { |r| r.is_a?(Puppet::Indirector::Request) and r.method == :find }
           @indirection.expire("/my/key")
         end
 
         it "should do nothing if no such instance is cached" do
           @cache.expects(:find).returns nil
 
           @indirection.expire("/my/key")
         end
 
         it "should log when expiring a found instance" do
           @cache.expects(:find).returns @cached
           @cache.stubs(:save)
 
           Puppet.expects(:info)
 
           @indirection.expire("/my/key")
         end
 
         it "should set the cached instance's expiration to a time in the past" do
           @cache.expects(:find).returns @cached
           @cache.stubs(:save)
 
           @cached.expects(:expiration=).with { |t| t < Time.now }
 
           @indirection.expire("/my/key")
         end
 
         it "should save the now expired instance back into the cache" do
           @cache.expects(:find).returns @cached
 
           @cached.expects(:expiration=).with { |t| t < Time.now }
 
           @cache.expects(:save)
 
           @indirection.expire("/my/key")
         end
 
         it "should use a request to save the expired resource to the cache" do
           @cache.expects(:find).returns @cached
 
           @cached.expects(:expiration=).with { |t| t < Time.now }
 
           @cache.expects(:save).with { |r| r.is_a?(Puppet::Indirector::Request) and r.instance == @cached and r.method == :save }.returns(@cached)
 
           @indirection.expire("/my/key")
         end
       end
     end
 
     after :each do
       @indirection.delete
       Puppet::Util::Cacher.expire
     end
   end
 
 
   describe "when managing indirection instances" do
     it "should allow an indirection to be retrieved by name" do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       Puppet::Indirector::Indirection.instance(:test).should equal(@indirection)
     end
 
     it "should return nil when the named indirection has not been created" do
       Puppet::Indirector::Indirection.instance(:test).should be_nil
     end
 
     it "should allow an indirection's model to be retrieved by name" do
       mock_model = mock('model')
       @indirection = Puppet::Indirector::Indirection.new(mock_model, :test)
       Puppet::Indirector::Indirection.model(:test).should equal(mock_model)
     end
 
     it "should return nil when no model matches the requested name" do
       Puppet::Indirector::Indirection.model(:test).should be_nil
     end
 
     after do
       @indirection.delete if defined?(@indirection)
     end
   end
 
   describe "when routing to the correct the terminus class" do
     before do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @terminus = mock 'terminus'
       @terminus_class = stub 'terminus class', :new => @terminus
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :default).returns(@terminus_class)
     end
 
     it "should fail if no terminus class can be picked" do
       proc { @indirection.terminus_class }.should raise_error(Puppet::DevError)
     end
 
     it "should choose the default terminus class if one is specified" do
       @indirection.terminus_class = :default
       @indirection.terminus_class.should equal(:default)
     end
 
     it "should use the provided Puppet setting if told to do so" do
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :my_terminus).returns(mock("terminus_class2"))
       Puppet.settings.expects(:value).with(:my_setting).returns("my_terminus")
       @indirection.terminus_setting = :my_setting
       @indirection.terminus_class.should equal(:my_terminus)
     end
 
     it "should fail if the provided terminus class is not valid" do
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :nosuchclass).returns(nil)
       proc { @indirection.terminus_class = :nosuchclass }.should raise_error(ArgumentError)
     end
 
     after do
       @indirection.delete if defined?(@indirection)
     end
   end
 
   describe "when specifying the terminus class to use" do
     before do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @terminus = mock 'terminus'
       @terminus_class = stub 'terminus class', :new => @terminus
     end
 
     it "should allow specification of a terminus type" do
       @indirection.should respond_to(:terminus_class=)
     end
 
     it "should fail to redirect if no terminus type has been specified" do
       proc { @indirection.find("blah") }.should raise_error(Puppet::DevError)
     end
 
     it "should fail when the terminus class name is an empty string" do
       proc { @indirection.terminus_class = "" }.should raise_error(ArgumentError)
     end
 
     it "should fail when the terminus class name is nil" do
       proc { @indirection.terminus_class = nil }.should raise_error(ArgumentError)
     end
 
     it "should fail when the specified terminus class cannot be found" do
       Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(nil)
       proc { @indirection.terminus_class = :foo }.should raise_error(ArgumentError)
     end
 
     it "should select the specified terminus class if a terminus class name is provided" do
       Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(@terminus_class)
       @indirection.terminus(:foo).should equal(@terminus)
     end
 
     it "should use the configured terminus class if no terminus name is specified" do
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
       @indirection.terminus_class = :foo
       @indirection.terminus.should equal(@terminus)
     end
 
     after do
       @indirection.delete if defined?(@indirection)
     end
   end
 
   describe "when managing terminus instances" do
     before do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @terminus = mock 'terminus'
       @terminus_class = mock 'terminus class'
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
     end
 
     it "should create an instance of the chosen terminus class" do
       @terminus_class.stubs(:new).returns(@terminus)
       @indirection.terminus(:foo).should equal(@terminus)
     end
 
     # Make sure it caches the terminus.
     it "should return the same terminus instance each time for a given name" do
       @terminus_class.stubs(:new).returns(@terminus)
       @indirection.terminus(:foo).should equal(@terminus)
       @indirection.terminus(:foo).should equal(@terminus)
     end
 
     it "should not create a terminus instance until one is actually needed" do
       Puppet::Indirector.expects(:terminus).never
       indirection = Puppet::Indirector::Indirection.new(mock('model'), :lazytest)
     end
 
     after do
       @indirection.delete
     end
   end
 
   describe "when deciding whether to cache" do
     before do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @terminus = mock 'terminus'
       @terminus_class = mock 'terminus class'
       @terminus_class.stubs(:new).returns(@terminus)
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
       @indirection.terminus_class = :foo
     end
 
     it "should provide a method for setting the cache terminus class" do
       @indirection.should respond_to(:cache_class=)
     end
 
     it "should fail to cache if no cache type has been specified" do
       proc { @indirection.cache }.should raise_error(Puppet::DevError)
     end
 
     it "should fail to set the cache class when the cache class name is an empty string" do
       proc { @indirection.cache_class = "" }.should raise_error(ArgumentError)
     end
 
     it "should allow resetting the cache_class to nil" do
       @indirection.cache_class = nil
       @indirection.cache_class.should be_nil
     end
 
     it "should fail to set the cache class when the specified cache class cannot be found" do
       Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(nil)
       proc { @indirection.cache_class = :foo }.should raise_error(ArgumentError)
     end
 
     after do
       @indirection.delete
     end
   end
 
   describe "when using a cache" do
     before :each do
       Puppet.settings.stubs(:value).with("test_terminus").returns("test_terminus")
       @terminus_class = mock 'terminus_class'
       @terminus = mock 'terminus'
       @terminus_class.stubs(:new).returns(@terminus)
       @cache = mock 'cache'
       @cache_class = mock 'cache_class'
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :cache_terminus).returns(@cache_class)
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :test_terminus).returns(@terminus_class)
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @indirection.terminus_class = :test_terminus
     end
 
     describe "and managing the cache terminus" do
       it "should not create a cache terminus at initialization" do
         # This is weird, because all of the code is in the setup.  If we got
         # new called on the cache class, we'd get an exception here.
       end
 
       it "should reuse the cache terminus" do
         @cache_class.expects(:new).returns(@cache)
         Puppet.settings.stubs(:value).with("test_cache").returns("cache_terminus")
         @indirection.cache_class = :cache_terminus
         @indirection.cache.should equal(@cache)
         @indirection.cache.should equal(@cache)
       end
     end
 
     describe "and saving" do
     end
 
     describe "and finding" do
     end
 
     after :each do
       @indirection.delete
     end
   end
 end
diff --git a/spec/unit/indirector/ldap_spec.rb b/spec/unit/indirector/ldap_spec.rb
index 31a3406e9..c071f870e 100755
--- a/spec/unit/indirector/ldap_spec.rb
+++ b/spec/unit/indirector/ldap_spec.rb
@@ -1,143 +1,139 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/indirector/ldap'
 
 describe Puppet::Indirector::Ldap do
   before do
     @indirection = stub 'indirection', :name => :testing
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
     @ldap_class = Class.new(Puppet::Indirector::Ldap) do
       def self.to_s
         "Testing::Mytype"
       end
     end
 
     @connection = mock 'ldap'
 
     @searcher = @ldap_class.new
   end
 
   describe "when searching ldap" do
     before do
       # Stub everything, and we can selectively replace with an expect as
       # we need to for testing.
       @searcher.stubs(:connection).returns(@connection)
       @searcher.stubs(:search_filter).returns(:filter)
       @searcher.stubs(:search_base).returns(:base)
       @searcher.stubs(:process)
 
       @request = stub 'request', :key => "yay"
     end
 
     it "should call the ldapsearch method with the search filter" do
       @searcher.expects(:search_filter).with("yay").returns("yay's filter")
       @searcher.expects(:ldapsearch).with("yay's filter")
       @searcher.find @request
     end
 
     it "should fail if no block is passed to the ldapsearch method" do
       proc { @searcher.ldapsearch("blah") }.should raise_error(ArgumentError)
     end
 
     it "should use the results of the ldapbase method as the ldap search base" do
       @searcher.stubs(:search_base).returns("mybase")
       @connection.expects(:search).with do |*args|
         args[0].should == "mybase"
         true
       end
       @searcher.find @request
     end
 
     it "should default to the value of the :search_base setting as the result of the ldapbase method" do
       Puppet.expects(:[]).with(:ldapbase).returns("myldapbase")
       searcher = @ldap_class.new
       searcher.search_base.should == "myldapbase"
     end
 
     it "should use the results of the :search_attributes method as the list of attributes to return" do
       @searcher.stubs(:search_attributes).returns(:myattrs)
       @connection.expects(:search).with do |*args|
         args[3].should == :myattrs
         true
       end
       @searcher.find @request
     end
 
     it "should use depth 2 when searching" do
       @connection.expects(:search).with do |*args|
         args[1].should == 2
         true
       end
       @searcher.find @request
     end
 
     it "should call process() on the first found entry" do
       @connection.expects(:search).yields("myresult")
       @searcher.expects(:process).with("myresult")
       @searcher.find @request
     end
 
     it "should reconnect and retry the search if there is a failure" do
       run = false
       @connection.stubs(:search).with do |*args|
         if run
           true
         else
           run = true
           raise "failed"
         end
       end.yields("myresult")
       @searcher.expects(:process).with("myresult")
 
       @searcher.find @request
     end
 
     it "should not reconnect on failure more than once" do
       count = 0
       @connection.stubs(:search).with do |*args|
         count += 1
         raise ArgumentError, "yay"
       end
       proc { @searcher.find(@request) }.should raise_error(Puppet::Error)
       count.should == 2
     end
 
     it "should return true if an entry is found" do
       @connection.expects(:search).yields("result")
       @searcher.ldapsearch("whatever") { |r| }.should be_true
     end
   end
 
-  describe "when connecting to ldap" do
-    confine "LDAP is not available" => Puppet.features.ldap?
-
+  describe "when connecting to ldap", :if => Puppet.features.ldap? do
     it "should create and start a Util::Ldap::Connection instance" do
       conn = mock 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
       @searcher.connection.should == "myconn"
     end
 
     it "should only create the ldap connection when asked for it the first time" do
       conn = mock 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
       @searcher.connection
     end
 
     it "should cache the connection" do
       conn = mock 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
       @searcher.connection.should equal(@searcher.connection)
     end
   end
 
-  describe "when reconnecting to ldap" do
-    confine "Not running on culain as root" => (Puppet.features.root? and Facter.value("hostname") == "culain")
-
+  describe "when reconnecting to ldap", :if => (Puppet.features.root? and Facter.value("hostname") == "culain") do
     it "should reconnect to ldap when connections are lost"
   end
 end
diff --git a/spec/unit/indirector/node/active_record_spec.rb b/spec/unit/indirector/node/active_record_spec.rb
index 3540ef738..69229e144 100755
--- a/spec/unit/indirector/node/active_record_spec.rb
+++ b/spec/unit/indirector/node/active_record_spec.rb
@@ -1,40 +1,38 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/node'
 
-describe "Puppet::Node::ActiveRecord" do
+describe "Puppet::Node::ActiveRecord", :if => Puppet.features.rails? && Puppet.features.sqlite? do
   include PuppetSpec::Files
 
-  confine "Missing Rails" => Puppet.features.rails?
-  confine "Missing sqlite" => Puppet.features.sqlite?
   before do
     require 'puppet/indirector/node/active_record'
   end
 
   it "should be a subclass of the ActiveRecord terminus class" do
     Puppet::Node::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
   end
 
   it "should use Puppet::Rails::Host as its ActiveRecord model" do
     Puppet::Node::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
   end
 
   it "should call fact_merge when a node is found" do
     db_instance = stub 'db_instance'
     Puppet::Node::ActiveRecord.ar_model.expects(:find_by_name).returns db_instance
 
     node = Puppet::Node.new("foo")
     db_instance.expects(:to_puppet).returns node
 
     Puppet[:statedir] = tmpdir('active_record_tmp')
     Puppet[:railslog] = '$statedir/rails.log'
     ar = Puppet::Node::ActiveRecord.new
 
     node.expects(:fact_merge)
 
     request = Puppet::Indirector::Request.new(:node, :find, "what.ever")
     ar.find(request)
   end
 end
diff --git a/spec/unit/indirector/queue_spec.rb b/spec/unit/indirector/queue_spec.rb
index 83e9c771d..00463ee0f 100755
--- a/spec/unit/indirector/queue_spec.rb
+++ b/spec/unit/indirector/queue_spec.rb
@@ -1,123 +1,121 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/indirector/queue'
 
 class Puppet::Indirector::Queue::TestClient
 end
 
 class FooExampleData
   attr_accessor :name
 
   def self.pson_create(pson)
     new(pson['data'].to_sym)
   end
 
   def initialize(name = nil)
     @name = name if name
   end
 
   def render(format = :pson)
     to_pson
   end
 
   def to_pson(*args)
     {:type => self.class.to_s, :data => name}.to_pson(*args)
   end
 end
 
-describe Puppet::Indirector::Queue do
-  confine "PSON library is missing; cannot test queueing" => Puppet.features.pson?
-
+describe Puppet::Indirector::Queue, :if => Puppet.features.pson? do
   before :each do
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :my_queue, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).with(:my_queue).returns(@indirection)
     @store_class = Class.new(Puppet::Indirector::Queue) do
       def self.to_s
         'MyQueue::MyType'
       end
     end
     @store = @store_class.new
 
     @subject_class = FooExampleData
     @subject = @subject_class.new
     @subject.name = :me
 
     Puppet.settings.stubs(:value).returns("bogus setting data")
     Puppet.settings.stubs(:value).with(:queue_type).returns(:test_client)
     Puppet::Util::Queue.stubs(:queue_type_to_class).with(:test_client).returns(Puppet::Indirector::Queue::TestClient)
 
     @request = stub 'request', :key => :me, :instance => @subject
   end
 
   it "should require PSON" do
     Puppet.features.expects(:pson?).returns false
 
     lambda { @store_class.new }.should raise_error(ArgumentError)
   end
 
   it 'should use the correct client type and queue' do
     @store.queue.should == :my_queue
     @store.client.should be_an_instance_of(Puppet::Indirector::Queue::TestClient)
   end
 
   describe "when saving" do
     it 'should render the instance using pson' do
       @subject.expects(:render).with(:pson)
       @store.client.stubs(:send_message)
       @store.save(@request)
     end
 
     it "should send the rendered message to the appropriate queue on the client" do
       @subject.expects(:render).returns "mypson"
 
       @store.client.expects(:send_message).with(:my_queue, "mypson")
 
       @store.save(@request)
     end
 
     it "should catch any exceptions raised" do
       @store.client.expects(:send_message).raises ArgumentError
 
       lambda { @store.save(@request) }.should raise_error(Puppet::Error)
     end
   end
 
   describe "when subscribing to the queue" do
     before do
       @store_class.stubs(:model).returns @model
     end
 
     it "should use the model's Format support to intern the message from pson" do
       @model.expects(:convert_from).with(:pson, "mymessage")
 
       @store_class.client.expects(:subscribe).yields("mymessage")
       @store_class.subscribe {|o| o }
     end
 
     it "should yield each interned received message" do
       @model.stubs(:convert_from).returns "something"
 
       @subject_two = @subject_class.new
       @subject_two.name = :too
 
       @store_class.client.expects(:subscribe).with(:my_queue).multiple_yields(@subject, @subject_two)
 
       received = []
       @store_class.subscribe do |obj|
         received.push(obj)
       end
 
       received.should == %w{something something}
     end
 
     it "should log but not propagate errors" do
       @store_class.client.expects(:subscribe).yields("foo")
       @store_class.expects(:intern).raises ArgumentError
       Puppet.expects(:err)
       @store_class.subscribe {|o| o }
     end
   end
 end
 
diff --git a/spec/unit/indirector/rest_spec.rb b/spec/unit/indirector/rest_spec.rb
index 3efbfce97..5f0fe363a 100755
--- a/spec/unit/indirector/rest_spec.rb
+++ b/spec/unit/indirector/rest_spec.rb
@@ -1,455 +1,455 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/indirector/rest'
 
-describe "a REST http call", :shared => true do
+shared_examples_for "a REST http call" do
   it "should accept a path" do
     lambda { @search.send(@method, *@arguments) }.should_not raise_error(ArgumentError)
   end
 
   it "should require a path" do
     lambda { @searcher.send(@method) }.should raise_error(ArgumentError)
   end
 
   it "should return the results of deserializing the response to the request" do
     conn = mock 'connection'
     conn.stubs(:put).returns @response
     conn.stubs(:delete).returns @response
     conn.stubs(:get).returns @response
     Puppet::Network::HttpPool.stubs(:http_instance).returns conn
 
     @searcher.expects(:deserialize).with(@response).returns "myobject"
 
     @searcher.send(@method, *@arguments).should == 'myobject'
   end
 end
 
 describe Puppet::Indirector::REST do
   before do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = stub('model', :supported_formats => %w{}, :convert_from => nil)
     @instance = stub('model instance', :name= => nil)
     @indirection = stub('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
     @rest_class = Class.new(Puppet::Indirector::REST) do
       def self.to_s
         "This::Is::A::Test::Class"
       end
     end
 
     @response = stub('mock response', :body => 'result', :code => "200")
     @response.stubs(:[]).with('content-type').returns "text/plain"
     @response.stubs(:[]).with('content-encoding').returns nil
 
     @searcher = @rest_class.new
     @searcher.stubs(:model).returns @model
   end
 
   it "should include the v1 REST API module" do
     Puppet::Indirector::REST.ancestors.should be_include(Puppet::Network::HTTP::API::V1)
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its server" do
     @rest_class.should respond_to(:use_server_setting)
   end
 
   it "should use any specified setting to pick the server" do
     @rest_class.expects(:server_setting).returns :servset
     Puppet.settings.expects(:value).with(:servset).returns "myserver"
     @rest_class.server.should == "myserver"
   end
 
   it "should default to :server for the server setting" do
     @rest_class.expects(:server_setting).returns nil
     Puppet.settings.expects(:value).with(:server).returns "myserver"
     @rest_class.server.should == "myserver"
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its port" do
     @rest_class.should respond_to(:use_port_setting)
   end
 
   it "should use any specified setting to pick the port" do
     @rest_class.expects(:port_setting).returns :servset
     Puppet.settings.expects(:value).with(:servset).returns "321"
     @rest_class.port.should == 321
   end
 
   it "should default to :port for the port setting" do
     @rest_class.expects(:port_setting).returns nil
     Puppet.settings.expects(:value).with(:masterport).returns "543"
     @rest_class.port.should == 543
   end
 
   describe "when deserializing responses" do
     it "should return nil if the response code is 404" do
       response = mock 'response'
       response.expects(:code).returns "404"
 
       @searcher.deserialize(response).should be_nil
     end
 
     [300,400,403,405,500,501,502,503,504].each { |rc|
       describe "when the response code is #{rc}" do
         before :each do
           @model.expects(:convert_from).never
 
           @response = mock 'response'
           @response.stubs(:code).returns rc.to_s
           @response.stubs(:[]).with('content-encoding').returns nil
           @response.stubs(:message).returns "There was a problem (header)"
         end
 
         it "should fail" do
           @response.stubs(:body).returns nil
           lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError)
         end
 
         it "should take the error message from the body, if present" do
           @response.stubs(:body).returns "There was a problem (body)"
           lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (body)")
         end
 
         it "should take the error message from the response header if the body is empty" do
           @response.stubs(:body).returns ""
           lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (header)")
         end
 
         it "should take the error message from the response header if the body is absent" do
           @response.stubs(:body).returns nil
           lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (header)")
         end
 
         describe "and with http compression" do
           it "should uncompress the body" do
             @response.stubs(:body).returns("compressed body")
             @searcher.expects(:uncompress_body).with(@response).returns("uncompressed")
             lambda { @searcher.deserialize(@response) }.should raise_error { |e| e.message =~ /uncompressed/ }
           end
         end
       end
     }
 
     it "should return the results of converting from the format specified by the content-type header if the response code is in the 200s" do
       @model.expects(:convert_from).with("myformat", "mydata").returns "myobject"
 
       response = mock 'response'
       response.stubs(:[]).with("content-type").returns "myformat"
       response.stubs(:[]).with("content-encoding").returns nil
       response.stubs(:body).returns "mydata"
       response.stubs(:code).returns "200"
 
       @searcher.deserialize(response).should == "myobject"
     end
 
     it "should convert and return multiple instances if the return code is in the 200s and 'multiple' is specified" do
       @model.expects(:convert_from_multiple).with("myformat", "mydata").returns "myobjects"
 
       response = mock 'response'
       response.stubs(:[]).with("content-type").returns "myformat"
       response.stubs(:[]).with("content-encoding").returns nil
       response.stubs(:body).returns "mydata"
       response.stubs(:code).returns "200"
 
       @searcher.deserialize(response, true).should == "myobjects"
     end
 
     it "should strip the content-type header to keep only the mime-type" do
       @model.expects(:convert_from).with("text/plain", "mydata").returns "myobject"
 
       response = mock 'response'
       response.stubs(:[]).with("content-type").returns "text/plain; charset=utf-8"
       response.stubs(:[]).with("content-encoding").returns nil
       response.stubs(:body).returns "mydata"
       response.stubs(:code).returns "200"
 
       @searcher.deserialize(response)
     end
 
     it "should uncompress the body" do
       @model.expects(:convert_from).with("myformat", "uncompressed mydata").returns "myobject"
 
       response = mock 'response'
       response.stubs(:[]).with("content-type").returns "myformat"
       response.stubs(:body).returns "compressed mydata"
       response.stubs(:code).returns "200"
 
       @searcher.expects(:uncompress_body).with(response).returns("uncompressed mydata")
 
       @searcher.deserialize(response).should == "myobject"
     end
   end
 
   describe "when creating an HTTP client" do
     before do
       Puppet.settings.stubs(:value).returns("rest_testing")
     end
 
     it "should use the class's server and port if the indirection request provides neither" do
       @request = stub 'request', :key => "foo", :server => nil, :port => nil
       @searcher.class.expects(:port).returns 321
       @searcher.class.expects(:server).returns "myserver"
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       @searcher.network(@request).should == "myconn"
     end
 
     it "should use the server from the indirection request if one is present" do
       @request = stub 'request', :key => "foo", :server => "myserver", :port => nil
       @searcher.class.stubs(:port).returns 321
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       @searcher.network(@request).should == "myconn"
     end
 
     it "should use the port from the indirection request if one is present" do
       @request = stub 'request', :key => "foo", :server => nil, :port => 321
       @searcher.class.stubs(:server).returns "myserver"
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       @searcher.network(@request).should == "myconn"
     end
   end
 
   describe "when doing a find" do
     before :each do
       @connection = stub('mock http connection', :get => @response)
       @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
       # Use a key with spaces, so we can test escaping
       @request = Puppet::Indirector::Request.new(:foo, :find, "foo bar")
     end
 
     it "should call the GET http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:get).returns @response
       @searcher.find(@request)
     end
 
     it "should deserialize and return the http response, setting name" do
       @connection.expects(:get).returns @response
 
       instance = stub 'object'
       instance.expects(:name=)
       @searcher.expects(:deserialize).with(@response).returns instance
 
       @searcher.find(@request).should == instance
     end
 
     it "should deserialize and return the http response, and not require name=" do
       @connection.expects(:get).returns @response
 
       instance = stub 'object'
       @searcher.expects(:deserialize).with(@response).returns instance
 
       @searcher.find(@request).should == instance
     end
 
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
       @connection.expects(:get).with { |path, args| path == "/my/uri" }.returns(@response)
       @searcher.find(@request)
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
       @searcher.model.expects(:supported_formats).returns %w{supported formats}
       @searcher.find(@request)
     end
 
     it "should add Accept-Encoding header" do
       @searcher.expects(:add_accept_encoding).returns({"accept-encoding" => "gzip"})
 
       @connection.expects(:get).with { |path, args| args["accept-encoding"] == "gzip" }.returns(@response)
       @searcher.find(@request)
     end
 
     it "should deserialize and return the network response" do
       @searcher.expects(:deserialize).with(@response).returns @instance
       @searcher.find(@request).should equal(@instance)
     end
 
     it "should set the name of the resulting instance to the asked-for name" do
       @searcher.expects(:deserialize).with(@response).returns @instance
       @instance.expects(:name=).with "foo bar"
       @searcher.find(@request)
     end
 
     it "should generate an error when result data deserializes fails" do
       @searcher.expects(:deserialize).raises(ArgumentError)
       lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when doing a search" do
     before :each do
       @connection = stub('mock http connection', :get => @response)
       @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
       @model.stubs(:convert_from_multiple)
 
       @request = Puppet::Indirector::Request.new(:foo, :search, "foo bar")
     end
 
     it "should call the GET http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:get).returns @response
       @searcher.search(@request)
     end
 
     it "should deserialize as multiple instances and return the http response" do
       @connection.expects(:get).returns @response
       @searcher.expects(:deserialize).with(@response, true).returns "myobject"
 
       @searcher.search(@request).should == 'myobject'
     end
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/mys/uri"
       @connection.expects(:get).with { |path, args| path == "/mys/uri" }.returns(@response)
       @searcher.search(@request)
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
       @searcher.model.expects(:supported_formats).returns %w{supported formats}
       @searcher.search(@request)
     end
 
     it "should return an empty array if serialization returns nil" do
       @model.stubs(:convert_from_multiple).returns nil
 
       @searcher.search(@request).should == []
     end
 
     it "should generate an error when result data deserializes fails" do
       @searcher.expects(:deserialize).raises(ArgumentError)
       lambda { @searcher.search(@request) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when doing a destroy" do
     before :each do
       @connection = stub('mock http connection', :delete => @response)
       @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
       @request = Puppet::Indirector::Request.new(:foo, :destroy, "foo bar")
     end
 
     it "should call the DELETE http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:delete).returns @response
       @searcher.destroy(@request)
     end
 
     it "should fail if any options are provided, since DELETE apparently does not support query options" do
       @request.stubs(:options).returns(:one => "two", :three => "four")
 
       lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
     end
 
     it "should deserialize and return the http response" do
       @connection.expects(:delete).returns @response
       @searcher.expects(:deserialize).with(@response).returns "myobject"
 
       @searcher.destroy(@request).should == 'myobject'
     end
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
       @connection.expects(:delete).with { |path, args| path == "/my/uri" }.returns(@response)
       @searcher.destroy(@request)
     end
 
     it "should not include the query string" do
       @connection.stubs(:delete).returns @response
       @searcher.destroy(@request)
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       @connection.expects(:delete).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
       @searcher.model.expects(:supported_formats).returns %w{supported formats}
       @searcher.destroy(@request)
     end
 
     it "should deserialize and return the network response" do
       @searcher.expects(:deserialize).with(@response).returns @instance
       @searcher.destroy(@request).should equal(@instance)
     end
 
     it "should generate an error when result data deserializes fails" do
       @searcher.expects(:deserialize).raises(ArgumentError)
       lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when doing a save" do
     before :each do
       @connection = stub('mock http connection', :put => @response)
       @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
       @instance = stub 'instance', :render => "mydata", :mime => "mime"
       @request = Puppet::Indirector::Request.new(:foo, :save, "foo bar")
       @request.instance = @instance
     end
 
     it "should call the PUT http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:put).returns @response
       @searcher.save(@request)
     end
 
     it "should fail if any options are provided, since DELETE apparently does not support query options" do
       @request.stubs(:options).returns(:one => "two", :three => "four")
 
       lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
     end
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
       @connection.expects(:put).with { |path, args| path == "/my/uri" }.returns(@response)
       @searcher.save(@request)
     end
 
     it "should serialize the instance using the default format and pass the result as the body of the request" do
       @instance.expects(:render).returns "serial_instance"
       @connection.expects(:put).with { |path, data, args| data == "serial_instance" }.returns @response
 
       @searcher.save(@request)
     end
 
     it "should deserialize and return the http response" do
       @connection.expects(:put).returns @response
       @searcher.expects(:deserialize).with(@response).returns "myobject"
 
       @searcher.save(@request).should == 'myobject'
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       @connection.expects(:put).with { |path, data, args| args["Accept"] == "supported, formats" }.returns(@response)
 
       @searcher.model.expects(:supported_formats).returns %w{supported formats}
       @searcher.save(@request)
     end
 
     it "should provide a Content-Type header containing the mime-type of the sent object" do
       @connection.expects(:put).with { |path, data, args| args['Content-Type'] == "mime" }.returns(@response)
 
       @instance.expects(:mime).returns "mime"
       @searcher.save(@request)
     end
 
     it "should deserialize and return the network response" do
       @searcher.expects(:deserialize).with(@response).returns @instance
       @searcher.save(@request).should equal(@instance)
     end
 
     it "should generate an error when result data deserializes fails" do
       @searcher.expects(:deserialize).raises(ArgumentError)
       lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
     end
   end
 end
diff --git a/spec/unit/indirector_spec.rb b/spec/unit/indirector_spec.rb
index fb21532ba..acbfc1726 100755
--- a/spec/unit/indirector_spec.rb
+++ b/spec/unit/indirector_spec.rb
@@ -1,157 +1,157 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/defaults'
 require 'puppet/indirector'
 
 describe Puppet::Indirector, " when available to a model" do
   before do
     @thingie = Class.new do
       extend Puppet::Indirector
     end
   end
 
   it "should provide a way for the model to register an indirection under a name" do
     @thingie.should respond_to(:indirects)
   end
 end
 
 describe Puppet::Indirector, "when registering an indirection" do
   before do
     @thingie = Class.new do
       extend Puppet::Indirector
       attr_reader :name
       def initialize(name)
         @name = name
       end
     end
   end
 
   it "should require a name when registering a model" do
     Proc.new {@thingie.send(:indirects) }.should raise_error(ArgumentError)
   end
 
   it "should create an indirection instance to manage each indirecting model" do
     @indirection = @thingie.indirects(:test)
     @indirection.should be_instance_of(Puppet::Indirector::Indirection)
   end
 
   it "should not allow a model to register under multiple names" do
     # Keep track of the indirection instance so we can delete it on cleanup
     @indirection = @thingie.indirects :first
     Proc.new { @thingie.indirects :second }.should raise_error(ArgumentError)
   end
 
   it "should make the indirection available via an accessor" do
     @indirection = @thingie.indirects :first
     @thingie.indirection.should equal(@indirection)
   end
 
   it "should pass any provided options to the indirection during initialization" do
     klass = mock 'terminus class'
     Puppet::Indirector::Indirection.expects(:new).with(@thingie, :first, {:some => :options})
     @indirection = @thingie.indirects :first, :some => :options
   end
 
   it "should extend the class with the Format Handler" do
     @indirection = @thingie.indirects :first
     @thingie.singleton_class.ancestors.should be_include(Puppet::Network::FormatHandler)
   end
 
   after do
     @indirection.delete if @indirection
   end
 end
 
-describe "Delegated Indirection Method", :shared => true do
+shared_examples_for "Delegated Indirection Method" do
   it "should delegate to the indirection" do
     @indirection.expects(@method)
     @thingie.send(@method, "me")
   end
 
   it "should pass all of the passed arguments directly to the indirection instance" do
     @indirection.expects(@method).with("me", :one => :two)
     @thingie.send(@method, "me", :one => :two)
   end
 
   it "should return the results of the delegation as its result" do
     request = mock 'request'
     @indirection.expects(@method).returns "yay"
     @thingie.send(@method, "me").should == "yay"
   end
 end
 
 describe Puppet::Indirector, "when redirecting a model" do
   before do
     @thingie = Class.new do
       extend Puppet::Indirector
       attr_reader :name
       def initialize(name)
         @name = name
       end
     end
     @indirection = @thingie.send(:indirects, :test)
   end
 
   it "should include the Envelope module in the model" do
     @thingie.ancestors.should be_include(Puppet::Indirector::Envelope)
   end
 
   describe "when finding instances via the model" do
     before { @method = :find }
     it_should_behave_like "Delegated Indirection Method"
   end
 
   describe "when destroying instances via the model" do
     before { @method = :destroy }
     it_should_behave_like "Delegated Indirection Method"
   end
 
   describe "when searching for instances via the model" do
     before { @method = :search }
     it_should_behave_like "Delegated Indirection Method"
   end
 
   describe "when expiring instances via the model" do
     before { @method = :expire }
     it_should_behave_like "Delegated Indirection Method"
   end
 
   # This is an instance method, so it behaves a bit differently.
   describe "when saving instances via the model" do
     before do
       @instance = @thingie.new("me")
     end
 
     it "should delegate to the indirection" do
       @indirection.expects(:save)
       @instance.save
     end
 
     it "should pass the instance and an optional key to the indirection's :save method" do
       @indirection.expects(:save).with("key", @instance)
       @instance.save "key"
     end
 
     it "should return the results of the delegation as its result" do
       request = mock 'request'
       @indirection.expects(:save).returns "yay"
       @instance.save.should == "yay"
     end
   end
 
   it "should give the model the ability to set the indirection terminus class" do
     @indirection.expects(:terminus_class=).with(:myterm)
     @thingie.terminus_class = :myterm
   end
 
   it "should give the model the ability to set the indirection cache class" do
     @indirection.expects(:cache_class=).with(:mycache)
     @thingie.cache_class = :mycache
   end
 
   after do
     @indirection.delete
   end
 end
diff --git a/spec/unit/module_spec.rb b/spec/unit/module_spec.rb
index c3436dfdd..37dad7e25 100755
--- a/spec/unit/module_spec.rb
+++ b/spec/unit/module_spec.rb
@@ -1,547 +1,545 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Puppet::Module do
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
     FileTest.stubs(:exist?).returns false
   end
 
   it "should have a class method that returns a named module from a given environment" do
     env = mock 'module'
     env.expects(:module).with("mymod").returns "yep"
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
     Puppet::Module.find("mymod", "myenv").should == "yep"
   end
 
   it "should return nil if asked for a named module that doesn't exist" do
     env = mock 'module'
     env.expects(:module).with("mymod").returns nil
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
     Puppet::Module.find("mymod", "myenv").should be_nil
   end
 
   it "should support a 'version' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.version = 1.09
     mod.version.should == 1.09
   end
 
   it "should support a 'source' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.source = "http://foo/bar"
     mod.source.should == "http://foo/bar"
   end
 
   it "should support a 'project_page' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.project_page = "http://foo/bar"
     mod.project_page.should == "http://foo/bar"
   end
 
   it "should support an 'author' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.author = "Luke Kanies <luke@madstop.com>"
     mod.author.should == "Luke Kanies <luke@madstop.com>"
   end
 
   it "should support a 'license' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.license = "GPL2"
     mod.license.should == "GPL2"
   end
 
   it "should support a 'summary' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.summary = "GPL2"
     mod.summary.should == "GPL2"
   end
 
   it "should support a 'description' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.description = "GPL2"
     mod.description.should == "GPL2"
   end
 
   it "should support specifying a compatible puppet version" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     mod.puppetversion.should == "0.25"
   end
 
   it "should validate that the puppet version is compatible" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     Puppet.expects(:version).returns "0.25"
     mod.validate_puppet_version
   end
 
   it "should fail if the specified puppet version is not compatible" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     Puppet.stubs(:version).returns "0.24"
     lambda { mod.validate_puppet_version }.should raise_error(Puppet::Module::IncompatibleModule)
   end
 
   describe "when specifying required modules" do
     it "should support specifying a required module" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
     end
 
     it "should support specifying multiple required modules" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
       mod.requires "baz"
     end
 
     it "should support specifying a required module and version" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
     end
 
     it "should fail when required modules are missing" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
 
       mod.environment.expects(:module).with("foobar").returns nil
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
     end
 
     it "should fail when required modules are present but of the wrong version" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
 
       foobar = Puppet::Module.new("foobar")
       foobar.version = 2.0
 
       mod.environment.expects(:module).with("foobar").returns foobar
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::IncompatibleModule)
     end
 
     it "should have valid dependencies when no dependencies have been specified" do
       mod = Puppet::Module.new("mymod")
 
       lambda { mod.validate_dependencies }.should_not raise_error
     end
 
     it "should fail when some dependencies are present but others aren't" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
       mod.requires "baz"
 
       mod.environment.expects(:module).with("foobar").returns Puppet::Module.new("foobar")
       mod.environment.expects(:module).with("baz").returns nil
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
     end
 
     it "should have valid dependencies when all dependencies are met" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
       mod.requires "baz"
 
       foobar = Puppet::Module.new("foobar")
       foobar.version = 1.0
 
       baz = Puppet::Module.new("baz")
 
       mod.environment.expects(:module).with("foobar").returns foobar
       mod.environment.expects(:module).with("baz").returns baz
 
       lambda { mod.validate_dependencies }.should_not raise_error
     end
 
     it "should validate its dependendencies on initialization" do
       Puppet::Module.any_instance.expects(:validate_dependencies)
       Puppet::Module.new("mymod")
     end
   end
 
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod = Puppet::Module.new("mymod")
       mod.supports "solaris"
     end
 
     it "should support specifying a supported platform and version" do
       mod = Puppet::Module.new("mymod")
       mod.supports "solaris", 1.0
     end
 
     it "should fail when not running on a supported platform" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
 
       mod.supports "hpux"
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::UnsupportedPlatform)
     end
 
     it "should fail when supported platforms are present but of the wrong version" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
       Facter.expects(:value).with("operatingsystemrelease").returns 2.0
 
       mod.supports "Solaris", 1.0
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
     end
 
     it "should be considered supported when no supported platforms have been specified" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       lambda { mod.validate_supported_platform }.should_not raise_error
     end
 
     it "should be considered supported when running on a supported platform" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
       Facter.expects(:value).with("operatingsystemrelease").returns 2.0
 
       mod.supports "Solaris", 1.0
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
     end
 
     it "should be considered supported when running on any of multiple supported platforms" do
       pending "Not sure how to send client platform to the module"
     end
 
     it "should validate its platform support on initialization" do
       pending "Not sure how to send client platform to the module"
     end
   end
 
   it "should return nil if asked for a module whose name is 'nil'" do
     Puppet::Module.find(nil, "myenv").should be_nil
   end
 
   it "should provide support for logging" do
     Puppet::Module.ancestors.should be_include(Puppet::Util::Logging)
   end
 
   it "should be able to be converted to a string" do
     Puppet::Module.new("foo").to_s.should == "Module foo"
   end
 
   it "should add the path to its string form if the module is found" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a"
     mod.to_s.should == "Module foo(/a)"
   end
 
   it "should fail if its name is not alphanumeric" do
     lambda { Puppet::Module.new(".something") }.should raise_error(Puppet::Module::InvalidName)
   end
 
   it "should require a name at initialization" do
     lambda { Puppet::Module.new }.should raise_error(ArgumentError)
   end
 
   it "should convert an environment name into an Environment instance" do
     Puppet::Module.new("foo", "prod").environment.should be_instance_of(Puppet::Node::Environment)
   end
 
   it "should accept an environment at initialization" do
     Puppet::Module.new("foo", :prod).environment.name.should == :prod
   end
 
   it "should use the default environment if none is provided" do
     env = Puppet::Node::Environment.new
     Puppet::Module.new("foo").environment.should equal(env)
   end
 
   it "should use any provided Environment instance" do
     env = Puppet::Node::Environment.new
     Puppet::Module.new("foo", env).environment.should equal(env)
   end
 
   it "should return the path to the first found instance in its environment's module paths as its path" do
     mod = Puppet::Module.new("foo")
     env = mock 'environment'
     mod.stubs(:environment).returns env
 
     env.expects(:modulepath).returns %w{/a /b /c}
 
     FileTest.expects(:exist?).with("/a/foo").returns false
     FileTest.expects(:exist?).with("/b/foo").returns true
     FileTest.expects(:exist?).with("/c/foo").never
 
     mod.path.should == "/b/foo"
   end
 
   it "should be considered existent if it exists in at least one module path" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns "/a/foo"
     mod.should be_exist
   end
 
   it "should be considered nonexistent if it does not exist in any of the module paths" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns nil
     mod.should_not be_exist
   end
 
   [:plugins, :templates, :files, :manifests].each do |filetype|
     dirname = filetype == :plugins ? "lib" : filetype.to_s
     it "should be able to return individual #{filetype}" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname, "my/file")
       FileTest.expects(:exist?).with(path).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should == path
     end
 
     it "should consider #{filetype} to be present if their base directory exists" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(path).returns true
       mod.send(filetype.to_s + "?").should be_true
     end
 
     it "should consider #{filetype} to be absent if their base directory does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(path).returns false
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should consider #{filetype} to be absent if the module base directory does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should return nil if asked to return individual #{filetype} that don't exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname, "my/file")
       FileTest.expects(:exist?).with(path).returns false
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return nil when asked for individual #{filetype} if the module does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return the base directory if asked for a nil path" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       base = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(base).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), nil).should == base
     end
   end
 
   %w{plugins files}.each do |filetype|
     short = filetype.sub(/s$/, '')
     dirname = filetype == "plugins" ? "lib" : filetype.to_s
     it "should be able to return the #{short} directory" do
       Puppet::Module.new("foo").should respond_to(short + "_directory")
     end
 
     it "should return the path to the #{short} directory" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
 
       mod.send(short + "_directory").should == "/a/foo/#{dirname}"
     end
   end
 
   it "should throw a warning if plugins are in a 'plugins' directory rather than a 'lib' directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
     FileTest.expects(:exist?).with("/a/foo/plugins").returns true
 
     mod.expects(:warning)
 
     mod.plugin_directory.should == "/a/foo/plugins"
   end
 
   it "should default to 'lib' for the plugins directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
     mod.plugin_directory.should == "/a/foo/lib"
   end
 end
 
 describe Puppet::Module, " when building its search path" do
   it "should use the current environment's search path if no environment is specified" do
     env = mock 'env'
     env.expects(:modulepath).returns "eh"
     Puppet::Node::Environment.expects(:new).with(nil).returns env
 
     Puppet::Module.modulepath.should == "eh"
   end
 
   it "should use the specified environment's search path if an environment is specified" do
     env = mock 'env'
     env.expects(:modulepath).returns "eh"
     Puppet::Node::Environment.expects(:new).with("foo").returns env
 
     Puppet::Module.modulepath("foo").should == "eh"
   end
 end
 
 describe Puppet::Module, "when finding matching manifests" do
   before do
     @mod = Puppet::Module.new("mymod")
     @mod.stubs(:path).returns "/a"
     @pq_glob_with_extension = "yay/*.xx"
     @fq_glob_with_extension = "/a/manifests/#{@pq_glob_with_extension}"
   end
 
   it "should return all manifests matching the glob pattern" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
     FileTest.stubs(:directory?).returns false
 
     @mod.match_manifests(@pq_glob_with_extension).should == %w{foo bar}
   end
 
   it "should not return directories" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
 
     FileTest.expects(:directory?).with("foo").returns false
     FileTest.expects(:directory?).with("bar").returns true
     @mod.match_manifests(@pq_glob_with_extension).should == %w{foo}
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
     Dir.expects(:glob).with("/a/manifests/init.{pp,rb}").returns(%w{/a/manifests/init.pp})
 
     @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
   end
 
   it "should return all manifests matching the glob pattern in all existing paths" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{a b})
 
     @mod.match_manifests(@pq_glob_with_extension).should == %w{a b}
   end
 
   it "should match the glob pattern plus '.{pp,rb}' if no extention is specified" do
     Dir.expects(:glob).with("/a/manifests/yay/foo.{pp,rb}").returns(%w{yay})
 
     @mod.match_manifests("yay/foo").should == %w{yay}
   end
 
   it "should return an empty array if no manifests matched" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns([])
 
     @mod.match_manifests(@pq_glob_with_extension).should == []
   end
 end
 
 describe Puppet::Module do
   before do
     Puppet::Module.any_instance.stubs(:path).returns "/my/mod/path"
     @module = Puppet::Module.new("foo")
   end
 
   it "should use 'License' in its current path as its metadata file" do
     @module.license_file.should == "/my/mod/path/License"
   end
 
   it "should return nil as its license file when the module has no path" do
     Puppet::Module.any_instance.stubs(:path).returns nil
     Puppet::Module.new("foo").license_file.should be_nil
   end
 
   it "should cache the license file" do
     Puppet::Module.any_instance.expects(:path).once.returns nil
     mod = Puppet::Module.new("foo")
     mod.license_file.should == mod.license_file
   end
 
   it "should use 'metadata.json' in its current path as its metadata file" do
     @module.metadata_file.should == "/my/mod/path/metadata.json"
   end
 
   it "should return nil as its metadata file when the module has no path" do
     Puppet::Module.any_instance.stubs(:path).returns nil
     Puppet::Module.new("foo").metadata_file.should be_nil
   end
 
   it "should cache the metadata file" do
     Puppet::Module.any_instance.expects(:path).once.returns nil
     mod = Puppet::Module.new("foo")
     mod.metadata_file.should == mod.metadata_file
   end
 
   it "should know if it has a metadata file" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns true
 
     @module.should be_has_metadata
   end
 
   it "should know if it is missing a metadata file" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns false
 
     @module.should_not be_has_metadata
   end
 
   it "should be able to parse its metadata file" do
     @module.should respond_to(:load_metadata)
   end
 
   it "should parse its metadata file on initialization if it is present" do
     Puppet::Module.any_instance.expects(:has_metadata?).returns true
     Puppet::Module.any_instance.expects(:load_metadata)
 
     Puppet::Module.new("yay")
   end
 
-  describe "when loading the medatada file" do
-    confine "Cannot test module metadata without json" => Puppet.features.json?
-
+  describe "when loading the medatada file", :if => Puppet.features.json? do
     before do
       @data = {
         :license => "GPL2",
         :author => "luke",
         :version => "1.0",
         :source => "http://foo/",
         :puppetversion => "0.25"
       }
       @text = @data.to_json
 
       @module = Puppet::Module.new("foo")
       @module.stubs(:metadata_file).returns "/my/file"
       File.stubs(:read).with("/my/file").returns @text
     end
 
     %w{source author version license}.each do |attr|
       it "should set #{attr} if present in the metadata file" do
         @module.load_metadata
         @module.send(attr).should == @data[attr.to_sym]
       end
 
       it "should fail if #{attr} is not present in the metadata file" do
         @data.delete(attr.to_sym)
         @text = @data.to_json
         File.stubs(:read).with("/my/file").returns @text
         lambda { @module.load_metadata }.should raise_error(Puppet::Module::MissingMetadata)
       end
     end
 
     it "should set puppetversion if present in the metadata file" do
       @module.load_metadata
       @module.puppetversion.should == @data[:puppetversion]
     end
 
 
     it "should fail if the discovered name is different than the metadata name"
   end
 end
diff --git a/spec/unit/network/formats_spec.rb b/spec/unit/network/formats_spec.rb
index 7c8e7b1f4..2c58a0534 100755
--- a/spec/unit/network/formats_spec.rb
+++ b/spec/unit/network/formats_spec.rb
@@ -1,337 +1,334 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/network/formats'
 
 class PsonTest
   attr_accessor :string
   def ==(other)
     string == other.string
   end
 
   def self.from_pson(data)
     new(data)
   end
 
   def initialize(string)
     @string = string
   end
 
   def to_pson(*args)
     {
       'type' => self.class.name,
       'data' => @string
     }.to_pson(*args)
   end
 end
 
 describe "Puppet Network Format" do
   it "should include a yaml format" do
     Puppet::Network::FormatHandler.format(:yaml).should_not be_nil
   end
 
   describe "yaml" do
     before do
       @yaml = Puppet::Network::FormatHandler.format(:yaml)
     end
 
     it "should have its mime type set to text/yaml" do
       @yaml.mime.should == "text/yaml"
     end
 
     it "should be supported on Strings" do
       @yaml.should be_supported(String)
     end
 
     it "should render by calling 'to_yaml' on the instance" do
       instance = mock 'instance'
       instance.expects(:to_yaml).returns "foo"
       @yaml.render(instance).should == "foo"
     end
 
     it "should render multiple instances by calling 'to_yaml' on the array" do
       instances = [mock('instance')]
       instances.expects(:to_yaml).returns "foo"
       @yaml.render_multiple(instances).should == "foo"
     end
 
     it "should intern by calling 'YAML.load'" do
       text = "foo"
       YAML.expects(:load).with("foo").returns "bar"
       @yaml.intern(String, text).should == "bar"
     end
 
     it "should intern multiples by calling 'YAML.load'" do
       text = "foo"
       YAML.expects(:load).with("foo").returns "bar"
       @yaml.intern_multiple(String, text).should == "bar"
     end
   end
 
-  describe "base64 compressed yaml" do
+  describe "base64 compressed yaml", :if => Puppet.features.zlib? do
     yaml = Puppet::Network::FormatHandler.format(:b64_zlib_yaml)
-    confine "We must have zlib" => Puppet.features.zlib?
 
     before do
       @yaml = Puppet::Network::FormatHandler.format(:b64_zlib_yaml)
     end
 
     it "should have its mime type set to text/b64_zlib_yaml" do
       @yaml.mime.should == "text/b64_zlib_yaml"
     end
 
     it "should render by calling 'to_yaml' on the instance" do
       instance = mock 'instance'
       instance.expects(:to_yaml).returns "foo"
       @yaml.render(instance)
     end
 
     it "should encode generated yaml on render" do
       instance = mock 'instance', :to_yaml => "foo"
 
       @yaml.expects(:encode).with("foo").returns "bar"
 
       @yaml.render(instance).should == "bar"
     end
 
     it "should render multiple instances by calling 'to_yaml' on the array" do
       instances = [mock('instance')]
       instances.expects(:to_yaml).returns "foo"
       @yaml.render_multiple(instances)
     end
 
     it "should encode generated yaml on render" do
       instances = [mock('instance')]
       instances.stubs(:to_yaml).returns "foo"
 
       @yaml.expects(:encode).with("foo").returns "bar"
 
       @yaml.render(instances).should == "bar"
     end
 
     it "should intern by calling decode" do
       text = "foo"
       @yaml.expects(:decode).with("foo").returns "bar"
       @yaml.intern(String, text).should == "bar"
     end
 
     it "should intern multiples by calling 'decode'" do
       text = "foo"
       @yaml.expects(:decode).with("foo").returns "bar"
       @yaml.intern_multiple(String, text).should == "bar"
     end
 
     it "should decode by base64 decoding, uncompressing and Yaml loading" do
       Base64.expects(:decode64).with("zorg").returns "foo"
       Zlib::Inflate.expects(:inflate).with("foo").returns "baz"
       YAML.expects(:load).with("baz").returns "bar"
       @yaml.decode("zorg").should == "bar"
     end
 
     it "should encode by compressing and base64 encoding" do
       Zlib::Deflate.expects(:deflate).with("foo", Zlib::BEST_COMPRESSION).returns "bar"
       Base64.expects(:encode64).with("bar").returns "baz"
       @yaml.encode("foo").should == "baz"
     end
 
     describe "when zlib is disabled" do
       before do
         Puppet[:zlib] = false
       end
 
       it "use_zlib? should return false" do
         @yaml.use_zlib?.should == false
       end
 
       it "should refuse to encode" do
         lambda{ @yaml.encode("foo") }.should raise_error
       end
 
       it "should refuse to decode" do
         lambda{ @yaml.decode("foo") }.should raise_error
       end
     end
 
     describe "when zlib is not installed" do
       it "use_zlib? should return false" do
         Puppet[:zlib] = true
         Puppet.features.expects(:zlib?).returns(false)
 
         @yaml.use_zlib?.should == false
       end
     end
 
   end
 
   it "should include a marshal format" do
     Puppet::Network::FormatHandler.format(:marshal).should_not be_nil
   end
 
   describe "marshal" do
     before do
       @marshal = Puppet::Network::FormatHandler.format(:marshal)
     end
 
     it "should have its mime type set to text/marshal" do
       Puppet::Network::FormatHandler.format(:marshal).mime.should == "text/marshal"
     end
 
     it "should be supported on Strings" do
       @marshal.should be_supported(String)
     end
 
     it "should render by calling 'Marshal.dump' on the instance" do
       instance = mock 'instance'
       Marshal.expects(:dump).with(instance).returns "foo"
       @marshal.render(instance).should == "foo"
     end
 
     it "should render multiple instances by calling 'to_marshal' on the array" do
       instances = [mock('instance')]
 
       Marshal.expects(:dump).with(instances).returns "foo"
       @marshal.render_multiple(instances).should == "foo"
     end
 
     it "should intern by calling 'Marshal.load'" do
       text = "foo"
       Marshal.expects(:load).with("foo").returns "bar"
       @marshal.intern(String, text).should == "bar"
     end
 
     it "should intern multiples by calling 'Marshal.load'" do
       text = "foo"
       Marshal.expects(:load).with("foo").returns "bar"
       @marshal.intern_multiple(String, text).should == "bar"
     end
   end
 
   describe "plaintext" do
     before do
       @text = Puppet::Network::FormatHandler.format(:s)
     end
 
     it "should have its mimetype set to text/plain" do
       @text.mime.should == "text/plain"
     end
 
     it "should use 'txt' as its extension" do
       @text.extension.should == "txt"
     end
   end
 
   describe "dot" do
     before do
       @dot = Puppet::Network::FormatHandler.format(:dot)
     end
 
     it "should have its mimetype set to text/dot" do
       @dot.mime.should == "text/dot"
     end
   end
 
   describe Puppet::Network::FormatHandler.format(:raw) do
     before do
       @format = Puppet::Network::FormatHandler.format(:raw)
     end
 
     it "should exist" do
       @format.should_not be_nil
     end
 
     it "should have its mimetype set to application/x-raw" do
       @format.mime.should == "application/x-raw"
     end
 
     it "should always be supported" do
       @format.should be_supported(String)
     end
 
     it "should fail if its multiple_render method is used" do
       lambda { @format.render_multiple("foo") }.should raise_error(NotImplementedError)
     end
 
     it "should fail if its multiple_intern method is used" do
       lambda { @format.intern_multiple(String, "foo") }.should raise_error(NotImplementedError)
     end
 
     it "should have a weight of 1" do
       @format.weight.should == 1
     end
   end
 
   it "should include a pson format" do
     Puppet::Network::FormatHandler.format(:pson).should_not be_nil
   end
 
-  describe "pson" do
-    confine "Missing 'pson' library" => Puppet.features.pson?
-
+  describe "pson", :if => Puppet.features.pson? do
     before do
       @pson = Puppet::Network::FormatHandler.format(:pson)
     end
 
     it "should have its mime type set to text/pson" do
       Puppet::Network::FormatHandler.format(:pson).mime.should == "text/pson"
     end
 
     it "should require the :render_method" do
       Puppet::Network::FormatHandler.format(:pson).required_methods.should be_include(:render_method)
     end
 
     it "should require the :intern_method" do
       Puppet::Network::FormatHandler.format(:pson).required_methods.should be_include(:intern_method)
     end
 
     it "should have a weight of 10" do
       @pson.weight.should == 10
     end
 
     describe "when supported" do
       it "should render by calling 'to_pson' on the instance" do
         instance = PsonTest.new("foo")
         instance.expects(:to_pson).returns "foo"
         @pson.render(instance).should == "foo"
       end
 
       it "should render multiple instances by calling 'to_pson' on the array" do
         instances = [mock('instance')]
 
         instances.expects(:to_pson).returns "foo"
 
         @pson.render_multiple(instances).should == "foo"
       end
 
       it "should intern by calling 'PSON.parse' on the text and then using from_pson to convert the data into an instance" do
         text = "foo"
         PSON.expects(:parse).with("foo").returns("type" => "PsonTest", "data" => "foo")
         PsonTest.expects(:from_pson).with("foo").returns "parsed_pson"
         @pson.intern(PsonTest, text).should == "parsed_pson"
       end
 
       it "should not render twice if 'PSON.parse' creates the appropriate instance" do
         text = "foo"
         instance = PsonTest.new("foo")
         PSON.expects(:parse).with("foo").returns(instance)
         PsonTest.expects(:from_pson).never
         @pson.intern(PsonTest, text).should equal(instance)
       end
 
       it "should intern by calling 'PSON.parse' on the text and then using from_pson to convert the actual into an instance if the pson has no class/data separation" do
         text = "foo"
         PSON.expects(:parse).with("foo").returns("foo")
         PsonTest.expects(:from_pson).with("foo").returns "parsed_pson"
         @pson.intern(PsonTest, text).should == "parsed_pson"
       end
 
       it "should intern multiples by parsing the text and using 'class.intern' on each resulting data structure" do
         text = "foo"
         PSON.expects(:parse).with("foo").returns ["bar", "baz"]
         PsonTest.expects(:from_pson).with("bar").returns "BAR"
         PsonTest.expects(:from_pson).with("baz").returns "BAZ"
         @pson.intern_multiple(PsonTest, text).should == %w{BAR BAZ}
       end
     end
   end
 end
diff --git a/spec/unit/network/http/compression_spec.rb b/spec/unit/network/http/compression_spec.rb
index b46941f46..c5bbbb064 100644
--- a/spec/unit/network/http/compression_spec.rb
+++ b/spec/unit/network/http/compression_spec.rb
@@ -1,199 +1,197 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe "http compression" do
 
   describe "when zlib is not available" do
     before(:each) do
       Puppet.features.stubs(:zlib?).returns false
 
       require 'puppet/network/http/compression'
       class HttpUncompressor
         include Puppet::Network::HTTP::Compression::None
       end
 
       @uncompressor = HttpUncompressor.new
     end
 
     it "should have a module function that returns the None underlying module" do
       Puppet::Network::HTTP::Compression.module.should == Puppet::Network::HTTP::Compression::None
     end
 
     it "should not add any Accept-Encoding header" do
       @uncompressor.add_accept_encoding({}).should == {}
     end
 
     it "should not tamper the body" do
       response = stub 'response', :body => "data"
       @uncompressor.uncompress_body(response).should == "data"
     end
 
     it "should yield an identity uncompressor" do
       response = stub 'response'
       @uncompressor.uncompress(response) { |u|
         u.should be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
       }
     end
   end
 
-  describe "when zlib is available" do
-    confine "Zlib is missing" => Puppet.features.zlib?
-
+  describe "when zlib is available", :if => Puppet.features.zlib? do
     before(:each) do
       Puppet.features.stubs(:zlib?).returns true
 
       require 'puppet/network/http/compression'
       class HttpUncompressor
         include Puppet::Network::HTTP::Compression::Active
       end
 
       @uncompressor = HttpUncompressor.new
     end
 
     it "should have a module function that returns the Active underlying module" do
       Puppet::Network::HTTP::Compression.module.should == Puppet::Network::HTTP::Compression::Active
     end
 
     it "should add an Accept-Encoding header when http compression is available" do
       Puppet.settings.expects(:[]).with(:http_compression).returns(true)
       headers = @uncompressor.add_accept_encoding({})
       headers.should have_key('accept-encoding')
       headers['accept-encoding'].should =~ /gzip/
       headers['accept-encoding'].should =~ /deflate/
       headers['accept-encoding'].should =~ /identity/
     end
 
     it "should not add Accept-Encoding header if http compression is not available" do
       Puppet.settings.stubs(:[]).with(:http_compression).returns(false)
       @uncompressor.add_accept_encoding({}).should == {}
     end
 
     describe "when uncompressing response body" do
       before do
         @response = stub 'response'
         @response.stubs(:[]).with('content-encoding')
         @response.stubs(:body).returns("mydata")
       end
 
       it "should return untransformed response body with no content-encoding" do
         @uncompressor.uncompress_body(@response).should == "mydata"
       end
 
       it "should return untransformed response body with 'identity' content-encoding" do
         @response.stubs(:[]).with('content-encoding').returns('identity')
         @uncompressor.uncompress_body(@response).should == "mydata"
       end
 
       it "should use a Zlib inflater with 'deflate' content-encoding" do
         @response.stubs(:[]).with('content-encoding').returns('deflate')
 
         inflater = stub 'inflater'
         Zlib::Inflate.expects(:new).returns(inflater)
         inflater.expects(:inflate).with("mydata").returns "uncompresseddata"
 
         @uncompressor.uncompress_body(@response).should == "uncompresseddata"
       end
 
       it "should use a GzipReader with 'gzip' content-encoding" do
         @response.stubs(:[]).with('content-encoding').returns('gzip')
 
         io = stub 'io'
         StringIO.expects(:new).with("mydata").returns io
 
         reader = stub 'gzip reader'
         Zlib::GzipReader.expects(:new).with(io).returns(reader)
         reader.expects(:read).returns "uncompresseddata"
 
         @uncompressor.uncompress_body(@response).should == "uncompresseddata"
       end
     end
 
     describe "when uncompressing by chunk" do
       before do
         @response = stub 'response'
         @response.stubs(:[]).with('content-encoding')
 
         @inflater = stub_everything 'inflater'
         Zlib::Inflate.stubs(:new).returns(@inflater)
       end
 
       it "should yield an identity uncompressor with no content-encoding" do
         @uncompressor.uncompress(@response) { |u|
           u.should be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
         }
       end
 
       it "should yield an identity uncompressor with 'identity' content-encoding" do
         @response.stubs(:[]).with('content-encoding').returns 'identity'
         @uncompressor.uncompress(@response) { |u|
           u.should be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
         }
       end
 
       %w{gzip deflate}.each do |c|
         it "should yield a Zlib uncompressor with '#{c}' content-encoding" do
           @response.stubs(:[]).with('content-encoding').returns c
           @uncompressor.uncompress(@response) { |u|
             u.should be_instance_of(Puppet::Network::HTTP::Compression::Active::ZlibAdapter)
           }
         end
       end
 
       it "should close the underlying adapter" do
         adapter = stub_everything 'adapter'
         Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
 
         adapter.expects(:close)
         @uncompressor.uncompress(@response) { |u| }
       end
     end
 
     describe "zlib adapter" do
       before do
         @inflater = stub_everything 'inflater'
         Zlib::Inflate.stubs(:new).returns(@inflater)
         @adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
       end
 
       it "should initialize the underlying inflater with gzip/zlib header parsing" do
         Zlib::Inflate.expects(:new).with(15+32)
         Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
       end
 
       it "should inflate the given chunk" do
         @inflater.expects(:inflate).with("chunk")
         @adapter.uncompress("chunk")
       end
 
       it "should return the inflated chunk" do
         @inflater.stubs(:inflate).with("chunk").returns("uncompressed")
         @adapter.uncompress("chunk").should == "uncompressed"
       end
 
       it "should try a 'regular' inflater on Zlib::DataError" do
         @inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
         inflater = stub_everything 'inflater2'
         inflater.expects(:inflate).with("chunk").returns("uncompressed")
         Zlib::Inflate.expects(:new).with.returns(inflater)
         @adapter.uncompress("chunk")
       end
 
       it "should raise the error the second time" do
         @inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
         Zlib::Inflate.expects(:new).with.returns(@inflater)
         lambda { @adapter.uncompress("chunk") }.should raise_error
       end
 
       it "should finish the stream on close" do
         @inflater.expects(:finish)
         @adapter.close
       end
 
       it "should close the stream on close" do
         @inflater.expects(:close)
         @adapter.close
       end
     end
   end
 end
diff --git a/spec/unit/network/http/mongrel/rest_spec.rb b/spec/unit/network/http/mongrel/rest_spec.rb
index 92a81a10b..fb24521d5 100755
--- a/spec/unit/network/http/mongrel/rest_spec.rb
+++ b/spec/unit/network/http/mongrel/rest_spec.rb
@@ -1,249 +1,248 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../../spec_helper'
 
 require 'puppet/network/http'
 
-describe "Puppet::Network::HTTP::MongrelREST" do
-  confine "Mongrel is not available" => Puppet.features.mongrel?
+describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel? do
   before do
     require 'puppet/network/http/mongrel/rest'
   end
 
 
   it "should include the Puppet::Network::HTTP::Handler module" do
     Puppet::Network::HTTP::MongrelREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
   end
 
   describe "when initializing" do
     it "should call the Handler's initialization hook with its provided arguments as the server and handler" do
       Puppet::Network::HTTP::MongrelREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
       Puppet::Network::HTTP::MongrelREST.new(:server => "my", :handler => "arguments")
     end
   end
 
   describe "when receiving a request" do
     before do
       @params = {}
       @request = stub('mongrel http request', :params => @params)
 
       @head = stub('response head')
       @body = stub('response body', :write => true)
       @response = stub('mongrel http response')
       @response.stubs(:start).yields(@head, @body)
       @model_class = stub('indirected model class')
       @mongrel = stub('mongrel http server', :register => true)
       Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
       @handler = Puppet::Network::HTTP::MongrelREST.new(:server => @mongrel, :handler => :foo)
     end
 
     describe "and using the HTTP Handler interface" do
       it "should return the HTTP_ACCEPT parameter as the accept header" do
         @params.expects(:[]).with("HTTP_ACCEPT").returns "myaccept"
         @handler.accept_header(@request).should == "myaccept"
       end
 
       it "should return the Content-Type parameter as the Content-Type header" do
         @params.expects(:[]).with("HTTP_CONTENT_TYPE").returns "mycontent"
         @handler.content_type_header(@request).should == "mycontent"
       end
 
       it "should use the REQUEST_METHOD as the http method" do
         @params.expects(:[]).with(Mongrel::Const::REQUEST_METHOD).returns "mymethod"
         @handler.http_method(@request).should == "mymethod"
       end
 
       it "should return the request path as the path" do
         @params.expects(:[]).with(Mongrel::Const::REQUEST_PATH).returns "/foo/bar"
         @handler.path(@request).should == "/foo/bar"
       end
 
       it "should return the request body as the body" do
         @request.expects(:body).returns StringIO.new("mybody")
         @handler.body(@request).should == "mybody"
       end
 
       it "should set the response's content-type header when setting the content type" do
         @header = mock 'header'
         @response.expects(:header).returns @header
         @header.expects(:[]=).with('Content-Type', "mytype")
 
         @handler.set_content_type(@response, "mytype")
       end
 
       it "should set the status and write the body when setting the response for a successful request" do
         head = mock 'head'
         body = mock 'body'
         @response.expects(:start).with(200).yields(head, body)
 
         body.expects(:write).with("mybody")
 
         @handler.set_response(@response, "mybody", 200)
       end
 
       describe "when the result is a File" do
         it "should use response send_file" do
           head = mock 'head'
           body = mock 'body'
           stat = stub 'stat', :size => 100
           file = stub 'file', :stat => stat, :path => "/tmp/path"
           file.stubs(:is_a?).with(File).returns(true)
 
           @response.expects(:start).with(200).yields(head, body)
           @response.expects(:send_status).with(100)
           @response.expects(:send_header)
           @response.expects(:send_file).with("/tmp/path")
 
           @handler.set_response(@response, file, 200)
         end
       end
 
       it "should set the status and reason and write the body when setting the response for a successful request" do
         head = mock 'head'
         body = mock 'body'
         @response.expects(:start).with(400, false, "mybody").yields(head, body)
 
         body.expects(:write).with("mybody")
 
         @handler.set_response(@response, "mybody", 400)
       end
     end
 
     describe "and determining the request parameters" do
       before do
         @request.stubs(:params).returns({})
       end
 
       it "should skip empty parameter values" do
         @request.expects(:params).returns('QUERY_STRING' => "&=")
         lambda { @handler.params(@request) }.should_not raise_error
       end
 
       it "should include the HTTP request parameters, with the keys as symbols" do
         @request.expects(:params).returns('QUERY_STRING' => 'foo=baz&bar=xyzzy')
         result = @handler.params(@request)
         result[:foo].should == "baz"
         result[:bar].should == "xyzzy"
       end
 
       it "should CGI-decode the HTTP parameters" do
         encoding = CGI.escape("foo bar")
         @request.expects(:params).returns('QUERY_STRING' => "foo=#{encoding}")
         result = @handler.params(@request)
         result[:foo].should == "foo bar"
       end
 
       it "should convert the string 'true' to the boolean" do
         @request.expects(:params).returns('QUERY_STRING' => 'foo=true')
         result = @handler.params(@request)
         result[:foo].should be_true
       end
 
       it "should convert the string 'false' to the boolean" do
         @request.expects(:params).returns('QUERY_STRING' => 'foo=false')
         result = @handler.params(@request)
         result[:foo].should be_false
       end
 
       it "should convert integer arguments to Integers" do
         @request.expects(:params).returns('QUERY_STRING' => 'foo=15')
         result = @handler.params(@request)
         result[:foo].should == 15
       end
 
       it "should convert floating point arguments to Floats" do
         @request.expects(:params).returns('QUERY_STRING' => 'foo=1.5')
         result = @handler.params(@request)
         result[:foo].should == 1.5
       end
 
       it "should YAML-load and URI-decode values that are YAML-encoded" do
         escaping = CGI.escape(YAML.dump(%w{one two}))
         @request.expects(:params).returns('QUERY_STRING' => "foo=#{escaping}")
         result = @handler.params(@request)
         result[:foo].should == %w{one two}
       end
 
       it "should not allow the client to set the node via the query string" do
         @request.stubs(:params).returns('QUERY_STRING' => "node=foo")
         @handler.params(@request)[:node].should be_nil
       end
 
       it "should not allow the client to set the IP address via the query string" do
         @request.stubs(:params).returns('QUERY_STRING' => "ip=foo")
         @handler.params(@request)[:ip].should be_nil
       end
 
       it "should pass the client's ip address to model find" do
         @request.stubs(:params).returns("REMOTE_ADDR" => "ipaddress")
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should pass the client's provided X-Forwared-For value as the ip" do
         @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipaddress")
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should pass the client's provided X-Forwared-For first value as the ip" do
         @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipproxy1,ipproxy2,ipaddress")
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should pass the client's provided X-Forwared-For value as the ip instead of the REMOTE_ADDR" do
         @request.stubs(:params).returns("REMOTE_ADDR" => "remote_addr")
         @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipaddress")
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
         @handler.params(@request)
       end
 
       it "should retrieve the hostname by matching the certificate parameter" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
         @handler.params(@request)[:node].should == "host.domain.com"
       end
 
       it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
         @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
         @handler.params(@request)
       end
 
       it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
         @handler.params(@request)[:authenticated].should be_true
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         @request.stubs(:params).returns("myheader" => "whatever", "certheader" => "/CN=host.domain.com")
         @handler.params(@request)[:authenticated].should be_false
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         @request.stubs(:params).returns("myheader" => nil, "certheader" => "SUCCESS")
         @handler.params(@request)[:authenticated].should be_false
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         @request.stubs(:params).returns("myheader" => nil)
         @handler.expects(:resolve_node).returns("host.domain.com")
         @handler.params(@request)[:node].should == "host.domain.com"
       end
     end
   end
 end
diff --git a/spec/unit/network/http/mongrel_spec.rb b/spec/unit/network/http/mongrel_spec.rb
index ac3d72bae..1e24be0c6 100755
--- a/spec/unit/network/http/mongrel_spec.rb
+++ b/spec/unit/network/http/mongrel_spec.rb
@@ -1,131 +1,125 @@
 #!/usr/bin/env ruby
 #
 #  Created by Rick Bradley on 2007-10-15.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'puppet/network/http'
 
-describe "Puppet::Network::HTTP::Mongrel", "after initializing" do
-  confine "Mongrel is not available" => Puppet.features.mongrel?
-
+describe "Puppet::Network::HTTP::Mongrel", "after initializing", :if => Puppet.features.mongrel? do
   it "should not be listening" do
     require 'puppet/network/http/mongrel'
 
     Puppet::Network::HTTP::Mongrel.new.should_not be_listening
   end
 end
 
-describe "Puppet::Network::HTTP::Mongrel", "when turning on listening" do
-  confine "Mongrel is not available" => Puppet.features.mongrel?
-
+describe "Puppet::Network::HTTP::Mongrel", "when turning on listening", :if => Puppet.features.mongrel? do
   before do
     require 'puppet/network/http/mongrel'
 
     @server = Puppet::Network::HTTP::Mongrel.new
     @mock_mongrel = mock('mongrel')
     @mock_mongrel.stubs(:run)
     @mock_mongrel.stubs(:register)
     Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
 
     @mock_puppet_mongrel = mock('puppet_mongrel')
     Puppet::Network::HTTPServer::Mongrel.stubs(:new).returns(@mock_puppet_mongrel)
 
     @listen_params = { :address => "127.0.0.1", :port => 31337, :protocols => [ :rest, :xmlrpc ], :xmlrpc_handlers => [ :status, :fileserver ] }
   end
 
   it "should fail if already listening" do
     @server.listen(@listen_params)
     Proc.new { @server.listen(@listen_params) }.should raise_error(RuntimeError)
   end
 
   it "should require at least one protocol" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :protocols == k}) }.should raise_error(ArgumentError)
   end
 
   it "should require a listening address to be specified" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :address == k})}.should raise_error(ArgumentError)
   end
 
   it "should require a listening port to be specified" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :port == k})}.should raise_error(ArgumentError)
   end
 
   it "should order a mongrel server to start" do
     @mock_mongrel.expects(:run)
     @server.listen(@listen_params)
   end
 
   it "should tell mongrel to listen on the specified address and port" do
     Mongrel::HttpServer.expects(:new).with("127.0.0.1", 31337).returns(@mock_mongrel)
     @server.listen(@listen_params)
   end
 
   it "should be listening" do
     Mongrel::HttpServer.expects(:new).returns(@mock_mongrel)
     @server.listen(@listen_params)
     @server.should be_listening
   end
 
   describe "when providing REST services" do
     it "should instantiate a handler at / for handling REST calls" do
       Puppet::Network::HTTP::MongrelREST.expects(:new).returns "myhandler"
       @mock_mongrel.expects(:register).with("/", "myhandler")
 
       @server.listen(@listen_params)
     end
 
     it "should use a Mongrel + REST class to configure Mongrel when REST services are requested" do
       @server.expects(:class_for_protocol).with(:rest).at_least_once.returns(Puppet::Network::HTTP::MongrelREST)
       @server.listen(@listen_params)
     end
   end
 
   describe "when providing XMLRPC services" do
     it "should do nothing if no xmlrpc handlers have been provided" do
       Puppet::Network::HTTPServer::Mongrel.expects(:new).never
       @server.listen(@listen_params.merge(:xmlrpc_handlers => []))
     end
 
     it "should create an instance of the existing Mongrel http server with the right handlers" do
       Puppet::Network::HTTPServer::Mongrel.expects(:new).with([:status, :master]).returns(@mock_puppet_mongrel)
       @server.listen(@listen_params.merge(:xmlrpc_handlers => [:status, :master]))
     end
 
     it "should register the Mongrel server instance at /RPC2" do
       @mock_mongrel.expects(:register).with("/RPC2", @mock_puppet_mongrel)
 
       @server.listen(@listen_params.merge(:xmlrpc_handlers => [:status, :master]))
     end
   end
 end
 
-describe "Puppet::Network::HTTP::Mongrel", "when turning off listening" do
-  confine "Mongrel is not available" => Puppet.features.mongrel?
-
+describe "Puppet::Network::HTTP::Mongrel", "when turning off listening", :if => Puppet.features.mongrel? do
   before do
     @mock_mongrel = mock('mongrel httpserver')
     @mock_mongrel.stubs(:run)
     @mock_mongrel.stubs(:register)
     Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
     @server = Puppet::Network::HTTP::Mongrel.new
     @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
   end
 
   it "should fail unless listening" do
     Proc.new { @server.unlisten }.should raise_error(RuntimeError)
   end
 
   it "should order mongrel server to stop" do
     @server.listen(@listen_params)
     @mock_mongrel.expects(:stop)
     @server.unlisten
   end
 
   it "should not be listening" do
     @server.listen(@listen_params)
     @mock_mongrel.stubs(:stop)
     @server.unlisten
     @server.should_not be_listening
   end
 end
diff --git a/spec/unit/network/http/rack/rest_spec.rb b/spec/unit/network/http/rack/rest_spec.rb
index 96cf84c37..3eed4a2cb 100755
--- a/spec/unit/network/http/rack/rest_spec.rb
+++ b/spec/unit/network/http/rack/rest_spec.rb
@@ -1,249 +1,247 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../../spec_helper'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 require 'puppet/network/http/rack/rest'
 
-describe "Puppet::Network::HTTP::RackREST" do
-  confine "Rack is not available" => Puppet.features.rack?
-
+describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
   it "should include the Puppet::Network::HTTP::Handler module" do
     Puppet::Network::HTTP::RackREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
   end
 
   describe "when initializing" do
     it "should call the Handler's initialization hook with its provided arguments" do
       Puppet::Network::HTTP::RackREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
       Puppet::Network::HTTP::RackREST.new(:server => "my", :handler => "arguments")
     end
   end
 
   describe "when serving a request" do
     before :all do
       @model_class = stub('indirected model class')
       Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
       @handler = Puppet::Network::HTTP::RackREST.new(:handler => :foo)
     end
 
     before :each do
       @response = Rack::Response.new
     end
 
     def mk_req(uri, opts = {})
       env = Rack::MockRequest.env_for(uri, opts)
       Rack::Request.new(env)
     end
 
     describe "and using the HTTP Handler interface" do
       it "should return the HTTP_ACCEPT parameter as the accept header" do
         req = mk_req('/', 'HTTP_ACCEPT' => 'myaccept')
         @handler.accept_header(req).should == "myaccept"
       end
 
       it "should return the CONTENT_TYPE parameter as the content type header" do
         req = mk_req('/', 'CONTENT_TYPE' => 'mycontent')
         @handler.content_type_header(req).should == "mycontent"
       end
 
       it "should use the REQUEST_METHOD as the http method" do
         req = mk_req('/', :method => 'MYMETHOD')
         @handler.http_method(req).should == "MYMETHOD"
       end
 
       it "should return the request path as the path" do
         req = mk_req('/foo/bar')
         @handler.path(req).should == "/foo/bar"
       end
 
       it "should return the request body as the body" do
         req = mk_req('/foo/bar', :input => 'mybody')
         @handler.body(req).should == "mybody"
       end
 
       it "should set the response's content-type header when setting the content type" do
         @header = mock 'header'
         @response.expects(:header).returns @header
         @header.expects(:[]=).with('Content-Type', "mytype")
 
         @handler.set_content_type(@response, "mytype")
       end
 
       it "should set the status and write the body when setting the response for a request" do
         @response.expects(:status=).with(400)
         @response.expects(:write).with("mybody")
 
         @handler.set_response(@response, "mybody", 400)
       end
 
       describe "when result is a File" do
         before :each do
           stat = stub 'stat', :size => 100
           @file = stub 'file', :stat => stat, :path => "/tmp/path"
           @file.stubs(:is_a?).with(File).returns(true)
         end
 
         it "should set the Content-Length header as a string" do
           @response.expects(:[]=).with("Content-Length", '100')
 
           @handler.set_response(@response, @file, 200)
         end
 
         it "should return a RackFile adapter as body" do
           @response.expects(:body=).with { |val| val.is_a?(Puppet::Network::HTTP::RackREST::RackFile) }
 
           @handler.set_response(@response, @file, 200)
         end
       end
     end
 
     describe "and determining the request parameters" do
       it "should include the HTTP request parameters, with the keys as symbols" do
         req = mk_req('/?foo=baz&bar=xyzzy')
         result = @handler.params(req)
         result[:foo].should == "baz"
         result[:bar].should == "xyzzy"
       end
 
       it "should CGI-decode the HTTP parameters" do
         encoding = CGI.escape("foo bar")
         req = mk_req("/?foo=#{encoding}")
         result = @handler.params(req)
         result[:foo].should == "foo bar"
       end
 
       it "should convert the string 'true' to the boolean" do
         req = mk_req("/?foo=true")
         result = @handler.params(req)
         result[:foo].should be_true
       end
 
       it "should convert the string 'false' to the boolean" do
         req = mk_req("/?foo=false")
         result = @handler.params(req)
         result[:foo].should be_false
       end
 
       it "should convert integer arguments to Integers" do
         req = mk_req("/?foo=15")
         result = @handler.params(req)
         result[:foo].should == 15
       end
 
       it "should convert floating point arguments to Floats" do
         req = mk_req("/?foo=1.5")
         result = @handler.params(req)
         result[:foo].should == 1.5
       end
 
       it "should YAML-load and CGI-decode values that are YAML-encoded" do
         escaping = CGI.escape(YAML.dump(%w{one two}))
         req = mk_req("/?foo=#{escaping}")
         result = @handler.params(req)
         result[:foo].should == %w{one two}
       end
 
       it "should not allow the client to set the node via the query string" do
         req = mk_req("/?node=foo")
         @handler.params(req)[:node].should be_nil
       end
 
       it "should not allow the client to set the IP address via the query string" do
         req = mk_req("/?ip=foo")
         @handler.params(req)[:ip].should be_nil
       end
 
       it "should pass the client's ip address to model find" do
         req = mk_req("/", 'REMOTE_ADDR' => 'ipaddress')
         @handler.params(req)[:ip].should == "ipaddress"
       end
 
       it "should set 'authenticated' to false if no certificate is present" do
         req = mk_req('/')
         @handler.params(req)[:authenticated].should be_false
       end
     end
 
     describe "with pre-validated certificates" do
 
       it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         req = mk_req('/', "myheader" => "/CN=host.domain.com")
         @handler.params(req)
       end
 
       it "should retrieve the hostname by matching the certificate parameter" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         req = mk_req('/', "myheader" => "/CN=host.domain.com")
         @handler.params(req)[:node].should == "host.domain.com"
       end
 
       it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
         req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
         @handler.params(req)
       end
 
       it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_true
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         req = mk_req('/', "myheader" => "whatever", "certheader" => "/CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_false
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         req = mk_req('/', "myheader" => nil, "certheader" => "/CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_false
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         req = mk_req('/', "myheader" => nil)
         @handler.expects(:resolve_node).returns("host.domain.com")
         @handler.params(req)[:node].should == "host.domain.com"
       end
     end
   end
 end
 
 describe Puppet::Network::HTTP::RackREST::RackFile do
   before(:each) do
     stat = stub 'stat', :size => 100
     @file = stub 'file', :stat => stat, :path => "/tmp/path"
     @rackfile = Puppet::Network::HTTP::RackREST::RackFile.new(@file)
   end
 
   it "should have an each method" do
     @rackfile.should be_respond_to(:each)
   end
 
   it "should yield file chunks by chunks" do
     @file.expects(:read).times(3).with(8192).returns("1", "2", nil)
     i = 1
     @rackfile.each do |chunk|
       chunk.to_i.should == i
       i += 1
     end
   end
 
   it "should have a close method" do
     @rackfile.should be_respond_to(:close)
   end
 
   it "should delegate close to File close" do
     @file.expects(:close)
     @rackfile.close
   end
 end
diff --git a/spec/unit/network/http/rack/xmlrpc_spec.rb b/spec/unit/network/http/rack/xmlrpc_spec.rb
index 870438f2c..e6411524e 100755
--- a/spec/unit/network/http/rack/xmlrpc_spec.rb
+++ b/spec/unit/network/http/rack/xmlrpc_spec.rb
@@ -1,158 +1,156 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../../spec_helper'
 require 'puppet/network/handler'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 require 'puppet/network/http/rack/xmlrpc' if Puppet.features.rack?
 
-describe "Puppet::Network::HTTP::RackXMLRPC" do
-  confine "Rack is not available" => Puppet.features.rack?
-
+describe "Puppet::Network::HTTP::RackXMLRPC", :if => Puppet.features.rack? do
   describe "when initializing" do
     it "should create an Puppet::Network::XMLRPCServer" do
       Puppet::Network::XMLRPCServer.expects(:new).returns stub_everything
       Puppet::Network::HTTP::RackXMLRPC.new([])
     end
 
     it "should create each handler" do
       handler = stub_everything 'handler'
       Puppet::Network::XMLRPCServer.any_instance.stubs(:add_handler)
       Puppet::Network::Handler.expects(:handler).returns(handler).times(2)
       Puppet::Network::HTTP::RackXMLRPC.new([:foo, :bar])
     end
 
     it "should add each handler to the XMLRPCserver" do
       handler = stub_everything 'handler'
       Puppet::Network::Handler.stubs(:handler).returns(handler)
       Puppet::Network::XMLRPCServer.any_instance.expects(:add_handler).times(2)
       Puppet::Network::HTTP::RackXMLRPC.new([:foo, :bar])
     end
   end
 
   describe "when serving a request" do
 
     before :each do
       foo_handler = stub_everything 'foo_handler'
       Puppet::Network::Handler.stubs(:handler).with(:foo).returns foo_handler
       Puppet::Network::XMLRPCServer.any_instance.stubs(:add_handler)
       Puppet::Network::XMLRPCServer.any_instance.stubs(:process).returns('<xml/>')
       @handler = Puppet::Network::HTTP::RackXMLRPC.new([:foo])
     end
 
     before :each do
       @response = Rack::Response.new
     end
 
     def mk_req(opts = {})
       opts[:method] = 'POST' if !opts[:method]
       opts['CONTENT_TYPE'] = 'text/xml; foo=bar' if !opts['CONTENT_TYPE']
       env = Rack::MockRequest.env_for('/RPC2', opts)
       Rack::Request.new(env)
     end
 
     it "should reject non-POST requests" do
       req = mk_req :method => 'PUT'
       @handler.process(req, @response)
       @response.status.should == 405
     end
 
     it "should reject non text/xml requests" do
       req = mk_req 'CONTENT_TYPE' => 'yadda/plain'
     end
 
     it "should create a ClientRequest" do
       cr = Puppet::Network::ClientRequest.new(nil, '127.0.0.1', false)
       Puppet::Network::ClientRequest.expects(:new).returns cr
       req = mk_req
       @handler.process(req, @response)
     end
 
     it "should let xmlrpcserver process the request" do
       Puppet::Network::XMLRPCServer.any_instance.expects(:process).returns('yay')
       req = mk_req
       @handler.process(req, @response)
     end
 
     it "should report the response as OK" do
       req = mk_req
       @handler.process(req, @response)
       @response.status.should == 200
     end
 
     it "should report the response with the correct content type" do
       req = mk_req
       @handler.process(req, @response)
       @response['Content-Type'].should == 'text/xml; charset=utf-8'
     end
 
     it "should set 'authenticated' to false if no certificate is present" do
       req = mk_req
       Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
       @handler.process(req, @response)
     end
 
     it "should use the client's ip address" do
       req = mk_req 'REMOTE_ADDR' => 'ipaddress'
       Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| ip == 'ipaddress' }
       @handler.process(req, @response)
     end
 
     describe "with pre-validated certificates" do
 
       it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         req = mk_req "myheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should retrieve the hostname by matching the certificate parameter" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| node == "host.domain.com" }
         req = mk_req "myheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
         req = mk_req "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == true }
         req = mk_req "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
         req = mk_req "myheader" => "whatever", "certheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
         req = mk_req "myheader" => nil, "certheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         Resolv.any_instance.expects(:getname).returns("host.domain.com")
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| node == "host.domain.com" }
         req = mk_req "myheader" => nil
         @handler.process(req, @response)
       end
     end
   end
 end
diff --git a/spec/unit/network/http/rack_spec.rb b/spec/unit/network/http/rack_spec.rb
index 8be9ccb50..434294ce8 100755
--- a/spec/unit/network/http/rack_spec.rb
+++ b/spec/unit/network/http/rack_spec.rb
@@ -1,103 +1,101 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'puppet/network/handler'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 
-describe "Puppet::Network::HTTP::Rack" do
-  confine "Rack is not available" => Puppet.features.rack?
-
+describe "Puppet::Network::HTTP::Rack", :if => Puppet.features.rack? do
   describe "while initializing" do
 
     it "should require a protocol specification" do
       Proc.new { Puppet::Network::HTTP::Rack.new({}) }.should raise_error(ArgumentError)
     end
 
     it "should not accept imaginary protocols" do
       Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:foo]}) }.should raise_error(ArgumentError)
     end
 
     it "should accept the REST protocol" do
       Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:rest]}) }.should_not raise_error(ArgumentError)
     end
 
     it "should create a RackREST instance" do
       Puppet::Network::HTTP::RackREST.expects(:new)
       Puppet::Network::HTTP::Rack.new({:protocols => [:rest]})
     end
 
     describe "with XMLRPC enabled" do
 
       it "should require XMLRPC handlers" do
         Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:xmlrpc]}) }.should raise_error(ArgumentError)
       end
 
       it "should create a RackXMLRPC instance" do
         Puppet::Network::HTTP::RackXMLRPC.expects(:new)
         Puppet::Network::HTTP::Rack.new({:protocols => [:xmlrpc], :xmlrpc_handlers => [:Status]})
       end
 
     end
 
   end
 
   describe "when called" do
 
     before :all do
       @app = Puppet::Network::HTTP::Rack.new({:protocols => [:rest]})
       # let's use Rack::Lint to verify that we're OK with the rack specification
       @linted = Rack::Lint.new(@app)
     end
 
     before :each do
       @env = Rack::MockRequest.env_for('/')
     end
 
     it "should create a Request object" do
       request = Rack::Request.new(@env)
       Rack::Request.expects(:new).returns request
       @linted.call(@env)
     end
 
     it "should create a Response object" do
       Rack::Response.expects(:new).returns stub_everything
       @app.call(@env) # can't lint when Rack::Response is a stub
     end
 
     it "should let RackREST process the request" do
       Puppet::Network::HTTP::RackREST.any_instance.expects(:process).once
       @linted.call(@env)
     end
 
     it "should catch unhandled exceptions from RackREST" do
       Puppet::Network::HTTP::RackREST.any_instance.expects(:process).raises(ArgumentError, 'test error')
       Proc.new { @linted.call(@env) }.should_not raise_error
     end
 
     it "should finish() the Response" do
       Rack::Response.any_instance.expects(:finish).once
       @app.call(@env) # can't lint when finish is a stub
     end
 
   end
 
   describe "when serving XMLRPC" do
 
     before :all do
       @app = Puppet::Network::HTTP::Rack.new({:protocols => [:rest, :xmlrpc], :xmlrpc_handlers => [:Status]})
       @linted = Rack::Lint.new(@app)
     end
 
     before :each do
       @env = Rack::MockRequest.env_for('/RPC2', :method => 'POST')
     end
 
     it "should use RackXMLRPC to serve /RPC2 requests" do
       Puppet::Network::HTTP::RackXMLRPC.any_instance.expects(:process).once
       @linted.call(@env)
     end
 
   end
 
 end
 
diff --git a/spec/unit/parser/collector_spec.rb b/spec/unit/parser/collector_spec.rb
index 908cda63a..4cab26c44 100755
--- a/spec/unit/parser/collector_spec.rb
+++ b/spec/unit/parser/collector_spec.rb
@@ -1,560 +1,556 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/rails'
 require 'puppet/parser/collector'
 
 describe Puppet::Parser::Collector, "when initializing" do
   before do
     @scope = mock 'scope'
     @resource_type = 'resource_type'
     @form = :exported
     @vquery = mock 'vquery'
     @equery = mock 'equery'
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, @form)
   end
 
   it "should require a scope" do
     @collector.scope.should equal(@scope)
   end
 
   it "should require a resource type" do
     @collector.type.should == 'Resource_type'
   end
 
   it "should only accept :virtual or :exported as the collector form" do
     proc { @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @vquery, @equery, :other) }.should raise_error(ArgumentError)
   end
 
   it "should accept an optional virtual query" do
     @collector.vquery.should equal(@vquery)
   end
 
   it "should accept an optional exported query" do
     @collector.equery.should equal(@equery)
   end
 
   it "should canonize the type name" do
     @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
     @collector.type.should == "Resource::Type"
   end
 
   it "should accept an optional resource override" do
     @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
     override = { :parameters => "whatever" }
     @collector.add_override(override)
     @collector.overrides.should equal(override)
   end
 
 end
 
 describe Puppet::Parser::Collector, "when collecting specific virtual resources" do
   before do
     @scope = mock 'scope'
     @vquery = mock 'vquery'
     @equery = mock 'equery'
 
     @collector = Puppet::Parser::Collector.new(@scope, "resource_type", @equery, @vquery, :virtual)
   end
 
   it "should not fail when it does not find any resources to collect" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     @scope.stubs(:findresource).returns(false)
     proc { @collector.evaluate }.should_not raise_error
   end
 
   it "should mark matched resources as non-virtual" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     one = stub_everything 'one'
     one.expects(:virtual=).with(false)
 
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
     @collector.evaluate
   end
 
   it "should return matched resources" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     one = stub_everything 'one'
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
     @collector.evaluate.should == [one]
   end
 
   it "should delete itself from the compile's collection list if it has found all of its resources" do
     @collector.resources = ["File[virtual1]"]
     one = stub_everything 'one'
     @compiler.expects(:delete_collection).with(@collector)
     @scope.expects(:compiler).returns(@compiler)
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @collector.evaluate
   end
 
   it "should not delete itself from the compile's collection list if it has unfound resources" do
     @collector.resources = ["File[virtual1]"]
     one = stub_everything 'one'
     @compiler.expects(:delete_collection).never
     @scope.stubs(:findresource).with("File[virtual1]").returns(nil)
     @collector.evaluate
   end
 end
 
 describe Puppet::Parser::Collector, "when collecting virtual and catalog resources" do
   before do
     @scope = mock 'scope'
     @compiler = mock 'compile'
     @scope.stubs(:compiler).returns(@compiler)
     @resource_type = "Mytype"
     @vquery = proc { |res| true }
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, nil, @vquery, :virtual)
   end
 
   it "should find all virtual resources matching the vquery" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should find all non-virtual resources matching the vquery" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => false
     two = stub_everything 'two', :type => "Mytype", :virtual? => false
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should mark all matched resources as non-virtual" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.evaluate
   end
 
   it "should return matched resources" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should return all resources of the correct type if there is no virtual query" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).with(false)
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, nil, nil, :virtual)
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should not return or mark resources of a different type" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => :other, :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).never
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one]
   end
 
   it "should create a resource with overridden parameters" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).with { |type, title, h|
       h[:parameters] == param
     }
 
     @collector.evaluate
   end
 
   it "should define a new allow all child_of? on overriden resource" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     source = stub 'source'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.add_override(:parameters => param, :source => source )
     Puppet::Parser::Resource.stubs(:new)
 
     source.expects(:meta_def).with { |name,block| name == :child_of? }
 
     @collector.evaluate
   end
 
 
   it "should not override already overriden resources for this same collection in a previous run" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).at_least(2).returns([one])
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).once.with { |type, title, h|
       h[:parameters] == param
     }
 
     @collector.evaluate
 
     @collector.evaluate
   end
 
   it "should not return resources that were collected in a previous run of this collector" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     @compiler.stubs(:resources).returns([one])
 
     @collector.evaluate
 
     @collector.evaluate.should be_false
   end
 
 
   it "should tell the compiler about the overriden resources" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
 
     one.expects(:virtual=).with(false)
     @compiler.expects(:resources).returns([one])
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.stubs(:new).returns("whatever")
 
     @compiler.expects(:add_override).with("whatever")
 
     @collector.evaluate
   end
 
   it "should not return or mark non-matching resources" do
     @collector.vquery = proc { |res| res.name == :one }
 
     one = stub_everything 'one', :name => :one, :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :name => :two, :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).never
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one]
   end
 end
 
-describe Puppet::Parser::Collector, "when collecting exported resources" do
-  confine "Cannot test Rails integration without ActiveRecord" => Puppet.features.rails?
-
+describe Puppet::Parser::Collector, "when collecting exported resources", :if => Puppet.features.rails? do
   before do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
     @resource_type = "Mytype"
     @equery = "test = true"
     @vquery = proc { |r| true }
 
     res = stub("resource 1")
     res.stubs(:type).returns @resource_type
     Puppet::Resource.stubs(:new).returns res
 
     Puppet.settings.stubs(:value).with(:storeconfigs).returns true
     Puppet.settings.stubs(:value).with(:environment).returns "production"
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
   end
 
   # Stub most of our interface to Rails.
   def stub_rails(everything = false)
     ActiveRecord::Base.stubs(:connected?).returns(false)
     Puppet::Rails.stubs(:init)
     if everything
       Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
       Puppet::Rails::Resource.stubs(:find).returns([])
     end
   end
 
   it "should just return false if :storeconfigs is not enabled" do
     Puppet.settings.expects(:value).with(:storeconfigs).returns false
     @collector.evaluate.should be_false
   end
 
   it "should use initialize the Rails support if ActiveRecord is not connected" do
     @compiler.stubs(:resources).returns([])
     ActiveRecord::Base.expects(:connected?).returns(false)
     Puppet::Rails.expects(:init)
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
     Puppet::Rails::Resource.stubs(:find).returns([])
 
     @collector.evaluate
   end
 
   it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do
     stub_rails(true)
 
     one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "one"
     two = stub 'two', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "two"
 
     one.stubs(:exported=)
     one.stubs(:virtual=)
     two.stubs(:exported=)
     two.stubs(:virtual=)
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should mark all returned resources as not virtual" do
     stub_rails(true)
 
     one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "one"
 
     one.stubs(:exported=)
     one.expects(:virtual=).with(false)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.evaluate.should == [one]
   end
 
   it "should convert all found resources into parser resources" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
     Puppet::Rails::Resource.stubs(:find).returns([one])
 
     resource = mock 'resource'
     one.expects(:to_resource).with(@scope).returns(resource)
     resource.stubs(:exported=)
     resource.stubs(:virtual=)
     resource.stubs(:ref)
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(nil)
 
     @compiler.stubs(:add_resource)
 
     @collector.evaluate.should == [resource]
   end
 
   it "should override all exported collected resources if collector has an override" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
     Puppet::Rails::Resource.stubs(:find).returns([one])
 
     resource = mock 'resource', :type => "Mytype"
     one.expects(:to_resource).with(@scope).returns(resource)
     resource.stubs(:exported=)
     resource.stubs(:virtual=)
     resource.stubs(:ref)
     resource.stubs(:title)
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(nil)
 
     param = stub 'param'
     @compiler.stubs(:add_override)
     @compiler.stubs(:add_resource)
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).once.with { |type, title, h|
       h[:parameters] == param
     }
 
     @collector.evaluate
   end
 
   it "should store converted resources in the compile's resource list" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
     Puppet::Rails::Resource.stubs(:find).returns([one])
 
     resource = mock 'resource'
     one.expects(:to_resource).with(@scope).returns(resource)
     resource.stubs(:exported=)
     resource.stubs(:virtual=)
     resource.stubs(:ref)
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(nil)
 
     @compiler.expects(:add_resource).with(@scope, resource)
 
     @collector.evaluate.should == [resource]
   end
 
   # This way one host doesn't store another host's resources as exported.
   it "should mark resources collected from the database as not exported" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
     Puppet::Rails::Resource.stubs(:find).returns([one])
 
     resource = mock 'resource'
     one.expects(:to_resource).with(@scope).returns(resource)
     resource.expects(:exported=).with(false)
     resource.stubs(:virtual=)
     resource.stubs(:ref)
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(nil)
 
     @compiler.stubs(:add_resource)
 
     @collector.evaluate
   end
 
   it "should fail if an equivalent resource already exists in the compile" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     rails = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :id => 1, :ref => "yay"
     inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :rails_id => 2
 
     Puppet::Rails::Resource.stubs(:find).returns([rails])
 
     resource = mock 'resource'
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(inmemory)
 
     @compiler.stubs(:add_resource)
 
     proc { @collector.evaluate }.should raise_error(Puppet::ParseError)
   end
 
   it "should ignore exported resources that match already-collected resources" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     rails = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :id => 1, :ref => "yay"
     inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :rails_id => 1
 
     Puppet::Rails::Resource.stubs(:find).returns([rails])
 
     resource = mock 'resource'
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(inmemory)
 
     @compiler.stubs(:add_resource)
 
     proc { @collector.evaluate }.should_not raise_error(Puppet::ParseError)
   end
 end
 
-describe Puppet::Parser::Collector, "when building its ActiveRecord query for collecting exported resources" do
-  confine "Cannot test Rails integration without ActiveRecord" => Puppet.features.rails?
-
+describe Puppet::Parser::Collector, "when building its ActiveRecord query for collecting exported resources", :if => Puppet.features.rails? do
   before do
     @scope = stub 'scope', :host => "myhost", :debug => nil
     @compiler = mock 'compile'
     @scope.stubs(:compiler).returns(@compiler)
     @resource_type = "Mytype"
     @equery = nil
     @vquery = proc { |r| true }
 
     @resource = stub_everything 'collected'
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
     @collector.stubs(:exported_resource).with(@resource).returns(@resource)
     @compiler.stubs(:resources).returns([])
 
     ActiveRecord::Base.stubs(:connected?).returns(false)
 
     Puppet::Rails.stubs(:init)
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
     Puppet::Rails::Resource.stubs(:find).returns([])
 
     Puppet.settings.stubs(:value).with(:storeconfigs).returns true
   end
 
   it "should exclude all resources from the host if ActiveRecord contains information for this host" do
     @host = mock 'host'
     @host.stubs(:id).returns 5
 
     Puppet::Rails::Host.expects(:find_by_name).with(@scope.host).returns(@host)
 
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:conditions][0] =~ /^host_id != \?/ and options[:conditions][1] == 5
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should join with parameter names, parameter values when querying ActiveRecord" do
     @collector.equery = "param_names.name = title"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:param_values => :param_name}
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should join with tag tables when querying ActiveRecord with a tag exported query" do
     @collector.equery = "puppet_tags.name = test"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:resource_tags => :puppet_tag}
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should not join parameters when querying ActiveRecord with a tag exported query" do
     @collector.equery = "puppet_tags.name = test"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:param_values => :param_name}
     }.returns([@resource])
 
     @collector.evaluate.should be_false
   end
 
   it "should only search for exported resources with the matching type" do
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:conditions][0].include?("(exported=? AND restype=?)") and options[:conditions][1] == true and options[:conditions][2] == "Mytype"
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should include the export query if one is provided" do
     @collector.equery = "test = true"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:conditions][0].include?("test = true")
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 end
diff --git a/spec/unit/parser/lexer_spec.rb b/spec/unit/parser/lexer_spec.rb
index d52add399..860326973 100755
--- a/spec/unit/parser/lexer_spec.rb
+++ b/spec/unit/parser/lexer_spec.rb
@@ -1,664 +1,665 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/parser/lexer'
 
 # This is a special matcher to match easily lexer output
-Spec::Matchers.define :be_like do |*expected|
+RSpec::Matchers.define :be_like do |*expected|
   match do |actual|
     expected.zip(actual).all? { |e,a| !e or a[0] == e or (e.is_a? Array and a[0] == e[0] and (a[1] == e[1] or (a[1].is_a?(Hash) and a[1][:value] == e[1]))) }
   end
 end
 __ = nil
 
 describe Puppet::Parser::Lexer do
   describe "when reading strings" do
     before { @lexer = Puppet::Parser::Lexer.new }
     it "should increment the line count for every carriage return in the string" do
       @lexer.line = 10
       @lexer.string = "this\nis\natest'"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 12
     end
 
     it "should not increment the line count for escapes in the string" do
       @lexer.line = 10
       @lexer.string = "this\\nis\\natest'"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 10
     end
 
     it "should not think the terminator is escaped, when preceeded by an even number of backslashes" do
       @lexer.line = 10
       @lexer.string = "here\nis\nthe\nstring\\\\'with\nextra\njunk"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 13
     end
   end
 end
 
 describe Puppet::Parser::Lexer::Token do
   before do
     @token = Puppet::Parser::Lexer::Token.new(%r{something}, :NAME)
   end
 
   [:regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate].each do |param|
     it "should have a #{param.to_s} reader" do
       @token.should be_respond_to(param)
     end
 
     it "should have a #{param.to_s} writer" do
       @token.should be_respond_to(param.to_s + "=")
     end
   end
 end
 
 describe Puppet::Parser::Lexer::Token, "when initializing" do
   it "should create a regex if the first argument is a string" do
     Puppet::Parser::Lexer::Token.new("something", :NAME).regex.should == %r{something}
   end
 
   it "should set the string if the first argument is one" do
     Puppet::Parser::Lexer::Token.new("something", :NAME).string.should == "something"
   end
 
   it "should set the regex if the first argument is one" do
     Puppet::Parser::Lexer::Token.new(%r{something}, :NAME).regex.should == %r{something}
   end
 end
 
 describe Puppet::Parser::Lexer::TokenList do
   before do
     @list = Puppet::Parser::Lexer::TokenList.new
   end
 
   it "should have a method for retrieving tokens by the name" do
     token = @list.add_token :name, "whatever"
     @list[:name].should equal(token)
   end
 
   it "should have a method for retrieving string tokens by the string" do
     token = @list.add_token :name, "whatever"
     @list.lookup("whatever").should equal(token)
   end
 
   it "should add tokens to the list when directed" do
     token = @list.add_token :name, "whatever"
     @list[:name].should equal(token)
   end
 
   it "should have a method for adding multiple tokens at once" do
     @list.add_tokens "whatever" => :name, "foo" => :bar
     @list[:name].should_not be_nil
     @list[:bar].should_not be_nil
   end
 
   it "should fail to add tokens sharing a name with an existing token" do
     @list.add_token :name, "whatever"
     lambda { @list.add_token :name, "whatever" }.should raise_error(ArgumentError)
   end
 
   it "should set provided options on tokens being added" do
     token = @list.add_token :name, "whatever", :skip_text => true
     token.skip_text.should == true
   end
 
   it "should define any provided blocks as a :convert method" do
     token = @list.add_token(:name, "whatever")  do "foo" end
     token.convert.should == "foo"
   end
 
   it "should store all string tokens in the :string_tokens list" do
     one = @list.add_token(:name, "1")
     @list.string_tokens.should be_include(one)
   end
 
   it "should store all regex tokens in the :regex_tokens list" do
     one = @list.add_token(:name, %r{one})
     @list.regex_tokens.should be_include(one)
   end
 
   it "should not store string tokens in the :regex_tokens list" do
     one = @list.add_token(:name, "1")
     @list.regex_tokens.should_not be_include(one)
   end
 
   it "should not store regex tokens in the :string_tokens list" do
     one = @list.add_token(:name, %r{one})
     @list.string_tokens.should_not be_include(one)
   end
 
   it "should sort the string tokens inversely by length when asked" do
     one = @list.add_token(:name, "1")
     two = @list.add_token(:other, "12")
     @list.sort_tokens
     @list.string_tokens.should == [two, one]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS do
   before do
     @lexer = Puppet::Parser::Lexer.new
   end
 
   {
     :LBRACK => '[',
     :RBRACK => ']',
     :LBRACE => '{',
     :RBRACE => '}',
     :LPAREN => '(',
     :RPAREN => ')',
     :EQUALS => '=',
     :ISEQUAL => '==',
     :GREATEREQUAL => '>=',
     :GREATERTHAN => '>',
     :LESSTHAN => '<',
     :LESSEQUAL => '<=',
     :NOTEQUAL => '!=',
     :NOT => '!',
     :COMMA => ',',
     :DOT => '.',
     :COLON => ':',
     :AT => '@',
     :LLCOLLECT => '<<|',
     :RRCOLLECT => '|>>',
     :LCOLLECT => '<|',
     :RCOLLECT => '|>',
     :SEMIC => ';',
     :QMARK => '?',
     :BACKSLASH => '\\',
     :FARROW => '=>',
     :PARROW => '+>',
     :APPENDS => '+=',
     :PLUS => '+',
     :MINUS => '-',
     :DIV => '/',
     :TIMES => '*',
     :LSHIFT => '<<',
     :RSHIFT => '>>',
     :MATCH => '=~',
     :NOMATCH => '!~',
     :IN_EDGE => '->',
     :OUT_EDGE => '<-',
     :IN_EDGE_SUB => '~>',
     :OUT_EDGE_SUB => '<~',
   }.each do |name, string|
     it "should have a token named #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
     end
 
     it "should match '#{string}' for the token #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].string.should == string
     end
   end
 
   {
     "case" => :CASE,
     "class" => :CLASS,
     "default" => :DEFAULT,
     "define" => :DEFINE,
     "import" => :IMPORT,
     "if" => :IF,
     "elsif" => :ELSIF,
     "else" => :ELSE,
     "inherits" => :INHERITS,
     "node" => :NODE,
     "and"  => :AND,
     "or"   => :OR,
     "undef"   => :UNDEF,
     "false" => :FALSE,
     "true" => :TRUE,
     "in" => :IN,
   }.each do |string, name|
     it "should have a keyword named #{name.to_s}" do
       Puppet::Parser::Lexer::KEYWORDS[name].should_not be_nil
     end
 
     it "should have the keyword for #{name.to_s} set to #{string}" do
       Puppet::Parser::Lexer::KEYWORDS[name].string.should == string
     end
   end
 
   # These tokens' strings don't matter, just that the tokens exist.
   [:STRING, :DQPRE, :DQMID, :DQPOST, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :MLCOMMENT, :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name|
     it "should have a token named #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
     end
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:CLASSNAME] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSNAME] }
 
   it "should match against lower-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "one::two"
   end
 
   it "should match against many lower-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "one::two::three::four::five"
   end
 
   it "should match against lower-case alpha-numeric terms prefixed by double colons" do
     @token.regex.should =~ "::one"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:CLASSREF] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSREF] }
 
   it "should match against single upper-case alpha-numeric terms" do
     @token.regex.should =~ "One"
   end
 
   it "should match against upper-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "One::Two"
   end
 
   it "should match against many upper-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "One::Two::Three::Four::Five"
   end
 
   it "should match against upper-case alpha-numeric terms prefixed by double colons" do
     @token.regex.should =~ "::One"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NAME] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:NAME] }
 
   it "should match against lower-case alpha-numeric terms" do
     @token.regex.should =~ "one-two"
   end
 
   it "should return itself and the value if the matched term is not a keyword" do
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(nil)
     @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 
   it "should return the keyword token and the value if the matched term is a keyword" do
     keyword = stub 'keyword', :name => :testing
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub("lexer"), "myval").should == [keyword, "myval"]
   end
 
   it "should return the BOOLEAN token and 'true' if the matched term is the string 'true'" do
     keyword = stub 'keyword', :name => :TRUE
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "true").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], true]
   end
 
   it "should return the BOOLEAN token and 'false' if the matched term is the string 'false'" do
     keyword = stub 'keyword', :name => :FALSE
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "false").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], false]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NUMBER] do
   before do
     @token = Puppet::Parser::Lexer::TOKENS[:NUMBER]
     @regex = @token.regex
   end
 
   it "should match against numeric terms" do
     @regex.should =~ "2982383139"
   end
 
   it "should match against float terms" do
     @regex.should =~ "29823.235"
   end
 
   it "should match against hexadecimal terms" do
     @regex.should =~ "0xBEEF0023"
   end
 
   it "should match against float with exponent terms" do
     @regex.should =~ "10e23"
   end
 
   it "should match against float terms with negative exponents" do
     @regex.should =~ "10e-23"
   end
 
   it "should match against float terms with fractional parts and exponent" do
     @regex.should =~ "1.234e23"
   end
 
   it "should return the NAME token and the value" do
     @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:COMMENT] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:COMMENT] }
 
   it "should match against lines starting with '#'" do
     @token.regex.should =~ "# this is a comment"
   end
 
   it "should be marked to get skipped" do
     @token.skip?.should be_true
   end
 
   it "should be marked to accumulate" do
     @token.accumulate?.should be_true
   end
 
   it "'s block should return the comment without the #" do
     @token.convert(@lexer,"# this is a comment")[1].should == "this is a comment"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:MLCOMMENT] do
   before do
     @token = Puppet::Parser::Lexer::TOKENS[:MLCOMMENT]
     @lexer = stub 'lexer', :line => 0
   end
 
   it "should match against lines enclosed with '/*' and '*/'" do
     @token.regex.should =~ "/* this is a comment */"
   end
 
   it "should match multiple lines enclosed with '/*' and '*/'" do
     @token.regex.should =~ """/*
       this is a comment
       */"""
   end
 
   it "should increase the lexer current line number by the amount of lines spanned by the comment" do
     @lexer.expects(:line=).with(2)
     @token.convert(@lexer, "1\n2\n3")
   end
 
   it "should not greedily match comments" do
     match = @token.regex.match("/* first */ word /* second */")
     match[1].should == " first "
   end
 
   it "should be marked to accumulate" do
     @token.accumulate?.should be_true
   end
 
   it "'s block should return the comment without the comment marks" do
     @lexer.stubs(:line=).with(0)
 
     @token.convert(@lexer,"/* this is a comment */")[1].should == "this is a comment"
   end
 
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:RETURN] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:RETURN] }
 
   it "should match against carriage returns" do
     @token.regex.should =~ "\n"
   end
 
   it "should be marked to initiate text skipping" do
     @token.skip_text.should be_true
   end
 
   it "should be marked to increment the line" do
     @token.incr_line.should be_true
   end
 end
 
 def tokens_scanned_from(s)
   lexer = Puppet::Parser::Lexer.new
   lexer.string = s
   lexer.fullscan[0..-2]
 end
 
 describe Puppet::Parser::Lexer,"when lexing strings" do
   {
     %q{'single quoted string')}                                     => [[:STRING,'single quoted string']],
     %q{"double quoted string"}                                      => [[:STRING,'double quoted string']],
     %q{'single quoted string with an escaped "\\'"'}                => [[:STRING,'single quoted string with an escaped "\'"']],
     %q{'single quoted string with an escaped "\$"'}                 => [[:STRING,'single quoted string with an escaped "\$"']],
     %q{'single quoted string with an escaped "\."'}                 => [[:STRING,'single quoted string with an escaped "\."']],
     %q{'single quoted string with an escaped "\n"'}                 => [[:STRING,'single quoted string with an escaped "\n"']],
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],
     %q{"string with an escaped '\\$'"}                              => [[:STRING,"string with an escaped '$'"]],
     %Q{"string with a line ending with a backslash: \\\nfoo"}       => [[:STRING,"string with a line ending with a backslash: foo"]],
     %q{"string with $v (but no braces)"}                            => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' (but no braces)']],
     %q["string with ${v} in braces"]                                => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' in braces']],
     %q["string with ${qualified::var} in braces"]                   => [[:DQPRE,"string with "],[:VARIABLE,'qualified::var'],[:DQPOST,' in braces']],
     %q{"string with $v and $v (but no braces)"}                     => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," (but no braces)"]],
     %q["string with ${v} and ${v} in braces"]                       => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," in braces"]],
     %q["string with ${'a nested single quoted string'} inside it."] => [[:DQPRE,"string with "],[:STRING,'a nested single quoted string'],[:DQPOST,' inside it.']],
     %q["string with ${['an array ',$v2]} in it."]                   => [[:DQPRE,"string with "],:LBRACK,[:STRING,"an array "],:COMMA,[:VARIABLE,"v2"],:RBRACK,[:DQPOST," in it."]],
     %q{a simple "scanner" test}                                     => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"scanner"],[:NAME,"test"]],
     %q{a simple 'single quote scanner' test}                        => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"single quote scanner"],[:NAME,"test"]],
     %q{a harder 'a $b \c"'}                                         => [[:NAME,"a"],[:NAME,"harder"], [:STRING,'a $b \c"']],
     %q{a harder "scanner test"}                                     => [[:NAME,"a"],[:NAME,"harder"], [:STRING,"scanner test"]],
     %q{a hardest "scanner \"test\""}                                => [[:NAME,"a"],[:NAME,"hardest"],[:STRING,'scanner "test"']],
     %Q{a hardestest "scanner \\"test\\"\n"}                         => [[:NAME,"a"],[:NAME,"hardestest"],[:STRING,%Q{scanner "test"\n}]],
     %q{function("call")}                                            => [[:NAME,"function"],[:LPAREN,"("],[:STRING,'call'],[:RPAREN,")"]],
     %q["string with ${(3+5)/4} nested math."]                       => [[:DQPRE,"string with "],:LPAREN,[:NAME,"3"],:PLUS,[:NAME,"5"],:RPAREN,:DIV,[:NAME,"4"],[:DQPOST," nested math."]],
     %q["$$$$"]                                                      => [[:STRING,"$$$$"]],
     %q["$variable"]                                                 => [[:DQPRE,""],[:VARIABLE,"variable"],[:DQPOST,""]],
     %q["$var$other"]                                                => [[:DQPRE,""],[:VARIABLE,"var"],[:DQMID,""],[:VARIABLE,"other"],[:DQPOST,""]],
     %q["foo$bar$"]                                                  => [[:DQPRE,"foo"],[:VARIABLE,"bar"],[:DQPOST,"$"]],
     %q["foo$$bar"]                                                  => [[:DQPRE,"foo$"],[:VARIABLE,"bar"],[:DQPOST,""]],
     %q[""]                                                          => [[:STRING,""]],
   }.each { |src,expected_result|
     it "should handle #{src} correctly" do
       tokens_scanned_from(src).should be_like(*expected_result)
     end
   }
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] }
 
   it "should match against alpha words prefixed with '$'" do
     @token.regex.should =~ '$this_var'
   end
 
   it "should return the VARIABLE token and the variable name stripped of the '$'" do
     @token.convert(stub("lexer"), "$myval").should == [Puppet::Parser::Lexer::TOKENS[:VARIABLE], "myval"]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:REGEX] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:REGEX] }
 
   it "should match against any expression enclosed in //" do
     @token.regex.should =~ '/this is a regex/'
   end
 
   it 'should not match if there is \n in the regex' do
     @token.regex.should_not =~ "/this is \n a regex/"
   end
 
   describe "when scanning" do
     it "should not consider escaped slashes to be the end of a regex" do
       tokens_scanned_from("$x =~ /this \\/ foo/").should be_like(__,__,[:REGEX,%r{this / foo}])
     end
 
     it "should not lex chained division as a regex" do
       tokens_scanned_from("$x = $a/$b/$c").collect { |name, data| name }.should_not be_include( :REGEX )
     end
 
     it "should accept a regular expression after NODE" do
       tokens_scanned_from("node /www.*\.mysite\.org/").should be_like(__,[:REGEX,Regexp.new("www.*\.mysite\.org")])
     end
 
     it "should accept regular expressions in a CASE" do
       s = %q{case $variable {
         "something": {$othervar = 4096 / 2}
         /regex/: {notice("this notably sucks")}
         }
       }
       tokens_scanned_from(s).should be_like(
         :CASE,:VARIABLE,:LBRACE,:STRING,:COLON,:LBRACE,:VARIABLE,:EQUALS,:NAME,:DIV,:NAME,:RBRACE,[:REGEX,/regex/],:COLON,:LBRACE,:NAME,:LPAREN,:STRING,:RPAREN,:RBRACE,:RBRACE
       )
     end
 
   end
 
 
   it "should return the REGEX token and a Regexp" do
     @token.convert(stub("lexer"), "/myregex/").should == [Puppet::Parser::Lexer::TOKENS[:REGEX], Regexp.new(/myregex/)]
   end
 end
 
 describe Puppet::Parser::Lexer, "when lexing comments" do
   before { @lexer = Puppet::Parser::Lexer.new }
 
   it "should accumulate token in munge_token" do
     token = stub 'token', :skip => true, :accumulate? => true, :incr_line => nil, :skip_text => false
 
     token.stubs(:convert).with(@lexer, "# this is a comment").returns([token, " this is a comment"])
     @lexer.munge_token(token, "# this is a comment")
     @lexer.munge_token(token, "# this is a comment")
 
     @lexer.getcomment.should == " this is a comment\n this is a comment\n"
   end
 
   it "should add a new comment stack level on LBRACE" do
     @lexer.string = "{"
 
     @lexer.expects(:commentpush)
 
     @lexer.fullscan
   end
 
   it "should return the current comments on getcomment" do
     @lexer.string = "# comment"
     @lexer.fullscan
 
     @lexer.getcomment.should == "comment\n"
   end
 
   it "should discard the previous comments on blank line" do
     @lexer.string = "# 1\n\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment.should == "2\n"
   end
 
   it "should skip whitespace before lexing the next token after a non-token" do
     tokens_scanned_from("/* 1\n\n */ \ntest").should be_like([:NAME, "test"])
   end
 
   it "should not return comments seen after the current line" do
     @lexer.string = "# 1\n\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment(1).should == ""
   end
 
   it "should return a comment seen before the current line" do
     @lexer.string = "# 1\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment(2).should == "1\n2\n"
   end
 end
 
 # FIXME: We need to rewrite all of these tests, but I just don't want to take the time right now.
 describe "Puppet::Parser::Lexer in the old tests" do
   before { @lexer = Puppet::Parser::Lexer.new }
 
   it "should do simple lexing" do
     {
       %q{\\}                      => [[:BACKSLASH,"\\"]],
       %q{simplest scanner test}   => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"]],
       %Q{returned scanner test\n} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"]]
     }.each { |source,expected|
       tokens_scanned_from(source).should be_like(*expected)
     }
   end
 
   it "should fail usefully" do
     lambda { tokens_scanned_from('^') }.should raise_error(RuntimeError)
   end
 
   it "should fail if the string is not set" do
     lambda { @lexer.fullscan }.should raise_error(Puppet::LexError)
   end
 
   it "should correctly identify keywords" do
     tokens_scanned_from("case").should be_like([:CASE, "case"])
   end
 
   it "should correctly parse class references" do
     %w{Many Different Words A Word}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF,t])}
   end
 
   # #774
   it "should correctly parse namespaced class refernces token" do
     %w{Foo ::Foo Foo::Bar ::Foo::Bar}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF, t]) }
   end
 
   it "should correctly parse names" do
     %w{this is a bunch of names}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) }
   end
 
   it "should correctly parse names with numerals" do
     %w{1name name1 11names names11}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) }
   end
 
   it "should correctly parse empty strings" do
     lambda { tokens_scanned_from('$var = ""') }.should_not raise_error
   end
 
   it "should correctly parse virtual resources" do
     tokens_scanned_from("@type {").should be_like([:AT, "@"], [:NAME, "type"], [:LBRACE, "{"])
   end
 
   it "should correctly deal with namespaces" do
     @lexer.string = %{class myclass}
     @lexer.fullscan
     @lexer.namespace.should == "myclass"
 
     @lexer.namepop
     @lexer.namespace.should == ""
 
     @lexer.string = "class base { class sub { class more"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub::more"
 
     @lexer.namepop
     @lexer.namespace.should == "base::sub"
   end
 
   it "should not put class instantiation on the namespace" do
     @lexer.string = "class base { class sub { class { mode"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub"
   end
 
   it "should correctly handle fully qualified names" do
     @lexer.string = "class base { class sub::more {"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub::more"
 
     @lexer.namepop
     @lexer.namespace.should == "base"
   end
 
   it "should correctly lex variables" do
     ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string|
       tokens_scanned_from(string).should be_like([:VARIABLE,string.sub(/^\$/,'')])
     end
   end
 end
 
-require 'puppettest/support/utils'
+require File.dirname(__FILE__) + '/../../../test/lib/puppettest'
+require File.dirname(__FILE__) + '/../../../test/lib/puppettest/support/utils'
 describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
   extend PuppetTest::Support::Utils
   textfiles do |file|
     it "should correctly lex #{file}" do
       lexer = Puppet::Parser::Lexer.new
       lexer.file = file
       lambda { lexer.fullscan }.should_not raise_error
     end
   end
 end
diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 7d2e8a84c..5a1c986b1 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -1,193 +1,192 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-9-12.
 #  Copyright (c) 2006. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppettest/support/utils'
 require 'puppettest/fileparsing'
 
 module ParsedMountTesting
   include PuppetTest::Support::Utils
   include PuppetTest::FileParsing
 
   def fake_fstab
     os = Facter['operatingsystem']
     if os == "Solaris"
       name = "solaris.fstab"
     elsif os == "FreeBSD"
       name = "freebsd.fstab"
     else
       # Catchall for other fstabs
       name = "linux.fstab"
     end
     oldpath = @provider_class.default_target
     fakefile(File::join("data/types/mount", name))
   end
 
   def mkmountargs
     mount = nil
 
     if defined?(@pcount)
       @pcount += 1
     else
       @pcount = 1
     end
     args = {
       :name => "/fspuppet#{@pcount}",
       :device => "/dev/dsk#{@pcount}",
     }
 
     @provider_class.fields(:parsed).each do |field|
       args[field] = "fake#{field}#{@pcount}" unless args.include? field
     end
 
     args
   end
 
   def mkmount
     hash = mkmountargs
     #hash[:provider] = @provider_class.name
 
     fakeresource = stub :type => :mount, :name => hash[:name]
     fakeresource.stubs(:[]).with(:name).returns(hash[:name])
     fakeresource.stubs(:should).with(:target).returns(nil)
 
     mount = @provider_class.new(fakeresource)
     hash[:record_type] = :parsed
     hash[:ensure] = :present
     mount.property_hash = hash
 
     mount
   end
 
   # Here we just create a fake host type that answers to all of the methods
   # but does not modify our actual system.
   def mkfaketype
     @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
   end
 end
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
 
 describe provider_class do
   before :each do
     @mount_class = Puppet::Type.type(:mount)
     @provider_class = @mount_class.provider(:parsed)
   end
 
 
   describe provider_class do
     include ParsedMountTesting
 
     it "should be able to parse all of the example mount tabs" do
       tab = fake_fstab
       @provider = @provider_class
 
       # LAK:FIXME Again, a relatively bad test, but I don't know how to rspec-ify this.
       # I suppose this is more of an integration test?  I dunno.
       fakedataparse(tab) do
         # Now just make we've got some mounts we know will be there
         hashes = @provider_class.target_records(tab).find_all { |i| i.is_a? Hash }
         (hashes.length > 0).should be_true
         root = hashes.find { |i| i[:name] == "/" }
 
         proc { @provider_class.to_file(hashes) }.should_not raise_error
       end
     end
 
     # LAK:FIXME I can't mock Facter because this test happens at parse-time.
     it "should default to /etc/vfstab on Solaris and /etc/fstab everywhere else" do
       should = case Facter.value(:operatingsystem)
         when "Solaris"; "/etc/vfstab"
         else
           "/etc/fstab"
         end
       Puppet::Type.type(:mount).provider(:parsed).default_target.should == should
     end
 
     it "should not crash on incomplete lines in fstab" do
       parse = @provider_class.parse <<-FSTAB
 /dev/incomplete
 /dev/device       name
       FSTAB
 
       lambda{ @provider_class.to_line(parse[0]) }.should_not raise_error
     end
   end
 
   describe provider_class, " when mounting an absent filesystem" do
     include ParsedMountTesting
 
     # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
     it "should flush the fstab to disk" do
       mount = mkmount
 
       # Mark the mount as absent
       mount.property_hash[:ensure] = :absent
 
       mount.stubs(:mountcmd) # just so we don't actually try to mount anything
 
       mount.expects(:flush)
       mount.mount
     end
   end
 
   describe provider_class, " when modifying the filesystem tab" do
     include ParsedMountTesting
     before do
       Puppet.settings.stubs(:use)
       # Never write to disk, only to RAM.
       #@provider_class.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
       @provider_class.stubs(:target_object).returns(Puppet::Util::FileType.filetype(:ram).new("eh"))
       @provider_class.clear
 
       @mount = mkmount
       @target = @provider_class.default_target
     end
 
     it "should write the mount to disk when :flush is called" do
       old_text = @provider_class.target_object(@provider_class.default_target).read
 
       @mount.flush
 
       text = @provider_class.target_object(@provider_class.default_target).read
       text.should == old_text + @mount.class.to_line(@mount.property_hash) + "\n"
     end
   end
 
-  describe provider_class, " when parsing information about the root filesystem" do
-    confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
+  describe provider_class, " when parsing information about the root filesystem", :if => Facter["operatingsystem"].value != "Darwin" do
     include ParsedMountTesting
 
     before do
       @mount = @mount_class.new :name => "/"
       @provider = @mount.provider
     end
 
     it "should have a filesystem tab" do
       FileTest.should be_exist(@provider_class.default_target)
     end
 
     it "should find the root filesystem" do
       @provider_class.prefetch("/" => @mount)
       @mount.provider.property_hash[:ensure].should == :present
     end
 
     it "should determine that the root fs is mounted" do
       @provider_class.prefetch("/" => @mount)
       @mount.provider.should be_mounted
     end
   end
 
   describe provider_class, " when mounting and unmounting" do
     include ParsedMountTesting
 
     it "should call the 'mount' command to mount the filesystem"
 
     it "should call the 'unmount' command to unmount the filesystem"
 
     it "should specify the filesystem when remounting a filesystem"
   end
 end
diff --git a/spec/unit/rails/host_spec.rb b/spec/unit/rails/host_spec.rb
index 324a673a9..4244f117f 100755
--- a/spec/unit/rails/host_spec.rb
+++ b/spec/unit/rails/host_spec.rb
@@ -1,163 +1,161 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe "Puppet::Rails::Host" do
-  confine "Cannot test without ActiveRecord" => Puppet.features.rails?
-
+describe "Puppet::Rails::Host", :if => Puppet.features.rails? do
   def column(name, type)
     ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
   end
 
   before do
     require 'puppet/rails/host'
 
     # Stub this so we don't need access to the DB.
     Puppet::Rails::Host.stubs(:columns).returns([column("name", "string"), column("environment", "string"), column("ip", "string")])
 
     @node = Puppet::Node.new("foo")
     @node.environment = "production"
     @node.ipaddress = "127.0.0.1"
 
     @host = stub 'host', :environment= => nil, :ip= => nil
   end
 
   describe "when converting a Puppet::Node instance into a Rails instance" do
     it "should modify any existing instance in the database" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should create a new instance in the database if none can be found" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
       Puppet::Rails::Host.expects(:new).with(:name => "foo").returns @host
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should copy the environment from the Puppet instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @node.environment = "production"
       @host.expects(:environment=).with {|x| x.name.to_s == 'production' }
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should copy the ipaddress from the Puppet instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @node.ipaddress = "192.168.0.1"
       @host.expects(:ip=).with "192.168.0.1"
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should not save the Rails instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @host.expects(:save).never
 
       Puppet::Rails::Host.from_puppet(@node)
     end
   end
 
   describe "when converting a Puppet::Rails::Host instance into a Puppet::Node instance" do
     before do
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @node = Puppet::Node.new("foo")
       Puppet::Node.stubs(:new).with("foo").returns @node
     end
 
     it "should create a new instance with the correct name" do
       Puppet::Node.expects(:new).with("foo").returns @node
 
       @host.to_puppet
     end
 
     it "should copy the environment from the Rails instance" do
       @host.environment = "prod"
       @node.expects(:environment=).with "prod"
       @host.to_puppet
     end
 
     it "should copy the ipaddress from the Rails instance" do
       @host.ip = "192.168.0.1"
       @node.expects(:ipaddress=).with "192.168.0.1"
       @host.to_puppet
     end
   end
 
   describe "when merging catalog resources and database resources" do
     before :each do
       Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
       @resource1 = stub_everything 'res1'
       @resource2 = stub_everything 'res2'
       @resources = [ @resource1, @resource2 ]
 
       @dbresource1 = stub_everything 'dbres1'
       @dbresource2 = stub_everything 'dbres2'
       @dbresources = { 1 => @dbresource1, 2 => @dbresource2 }
 
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @host.stubs(:find_resources).returns(@dbresources)
       @host.stubs(:find_resources_parameters_tags)
       @host.stubs(:compare_to_catalog)
       @host.stubs(:id).returns(1)
     end
 
     it "should find all database resources" do
       @host.expects(:find_resources)
 
       @host.merge_resources(@resources)
     end
 
     it "should find all paramaters and tags for those database resources" do
       @host.expects(:find_resources_parameters_tags).with(@dbresources)
 
       @host.merge_resources(@resources)
     end
 
     it "should compare all database resources to catalog" do
       @host.expects(:compare_to_catalog).with(@dbresources, @resources)
 
       @host.merge_resources(@resources)
     end
 
     it "should compare only exported resources in thin_storeconfigs mode" do
       Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
       @resource1.stubs(:exported?).returns(true)
 
       @host.expects(:compare_to_catalog).with(@dbresources, [ @resource1 ])
 
       @host.merge_resources(@resources)
     end
   end
 
   describe "when searching the database for host resources" do
     before :each do
       Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
       @resource1 = stub_everything 'res1', :id => 1
       @resource2 = stub_everything 'res2', :id => 2
       @resources = [ @resource1, @resource2 ]
 
       @dbresources = stub 'resources'
       @dbresources.stubs(:find).returns(@resources)
 
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @host.stubs(:resources).returns(@dbresources)
     end
 
     it "should return a hash keyed by id of all resources" do
       @host.find_resources.should == { 1 => @resource1, 2 => @resource2 }
     end
 
     it "should return a hash keyed by id of only exported resources in thin_storeconfigs mode" do
       Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
       @dbresources.expects(:find).with { |*h| h[1][:conditions] == { :exported => true } }.returns([])
 
       @host.find_resources
     end
   end
 end
diff --git a/spec/unit/rails/param_value_spec.rb b/spec/unit/rails/param_value_spec.rb
index 243456e89..f67022a14 100755
--- a/spec/unit/rails/param_value_spec.rb
+++ b/spec/unit/rails/param_value_spec.rb
@@ -1,50 +1,48 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/rails'
 
-describe "Puppet::Rails::ParamValue" do
-  confine "Cannot test without ActiveRecord" => Puppet.features.rails?
-
+describe "Puppet::Rails::ParamValue", :if => Puppet.features.rails? do
   def column(name, type)
     ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
   end
 
   before do
     require 'puppet/rails/param_value'
 
     name = stub 'param_name', :name => "foo"
 
     # Stub this so we don't need access to the DB.
     Puppet::Rails::ParamValue.stubs(:columns).returns([column("value", "string")])
     Puppet::Rails::ParamName.stubs(:find_or_create_by_name).returns(name)
   end
 
   describe "when creating initial parameter values" do
     it "should return an array of hashes" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, %w{a b})[0].should be_instance_of(Hash)
     end
 
     it "should return hashes for each value with the parameter name set as the ParamName instance" do
       name = stub 'param_name', :name => "foo"
       Puppet::Rails::ParamName.expects(:find_or_create_by_name).returns(name)
 
       result = Puppet::Rails::ParamValue.from_parser_param(:myparam, "a")[0]
       result[:value].should == "a"
       result[:param_name].should == name
     end
 
     it "should return an array of hashes even when only one parameter is provided" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, "a")[0].should be_instance_of(Hash)
     end
 
     it "should convert all arguments into strings" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, 50)[0][:value].should == "50"
     end
 
     it "should not convert Resource References into strings" do
       ref = Puppet::Resource.new(:file, "/file")
       Puppet::Rails::ParamValue.from_parser_param(:myparam, ref)[0][:value].should == ref
     end
   end
 end
diff --git a/spec/unit/rails/resource_spec.rb b/spec/unit/rails/resource_spec.rb
index 6e23d2020..e5bd8a6c9 100755
--- a/spec/unit/rails/resource_spec.rb
+++ b/spec/unit/rails/resource_spec.rb
@@ -1,124 +1,122 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/rails'
 
-describe "Puppet::Rails::Resource" do
-  confine "Cannot test without ActiveRecord" => Puppet.features.rails?
-
+describe "Puppet::Rails::Resource", :if => Puppet.features.rails? do
   def column(name, type)
     ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
   end
 
   before do
     require 'puppet/rails/resource'
 
     # Stub this so we don't need access to the DB.
     Puppet::Rails::Resource.stubs(:columns).returns([column("title", "string"), column("restype", "string"), column("exported", "boolean")])
   end
 
   describe "when creating initial resource arguments" do
     it "should set the restype to the resource's type" do
       Puppet::Rails::Resource.rails_resource_initial_args(Puppet::Resource.new(:file, "/file"))[:restype].should == "File"
     end
 
     it "should set the title to the resource's title" do
       Puppet::Rails::Resource.rails_resource_initial_args(Puppet::Resource.new(:file, "/file"))[:title].should == "/file"
     end
 
     it "should set the line to the resource's line if one is available" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.line = 50
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:line].should == 50
     end
 
     it "should set 'exported' to true of the resource is exported" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = true
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_true
     end
 
     it "should set 'exported' to false of the resource is not exported" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = false
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_false
 
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = nil
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_false
     end
   end
 
   describe "when merging in a parser resource" do
     before do
       @parser = mock 'parser resource'
 
       @resource = Puppet::Rails::Resource.new
       [:merge_attributes, :merge_parameters, :merge_tags, :save].each { |m| @resource.stubs(m) }
     end
 
     it "should merge the attributes" do
       @resource.expects(:merge_attributes).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should merge the parameters" do
       @resource.expects(:merge_parameters).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should merge the tags" do
       @resource.expects(:merge_tags).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should save itself" do
       @resource.expects(:save)
 
       @resource.merge_parser_resource(@parser)
     end
   end
 
   describe "merge_parameters" do
     it "should replace values that have changed" do
       @resource = Puppet::Rails::Resource.new
       @resource.params_list = [{"name" => "replace", "value" => 1, "id" => 100 }]
 
       Puppet::Rails::ParamValue.expects(:delete).with([100])
       param_values = stub "param_values"
       param_values.expects(:build).with({:value=>nil, :param_name=>nil, :line=>{"replace"=>2}})
       @resource.stubs(:param_values).returns(param_values)
 
       Puppet::Rails::ParamName.stubs(:accumulate_by_name)
 
       merge_resource = stub "merge_resource"
       merge_resource.expects(:line).returns({ "replace" => 2 })
       merge_resource.stubs(:each).yields([["replace", 2]])
 
       @resource.merge_parameters(merge_resource)
     end
   end
 
   describe "#to_resource" do
     it "should instantiate a Puppet::Parser::Resource" do
       scope = stub "scope", :source => nil, :environment => nil, :namespaces => nil
 
       @resource = Puppet::Rails::Resource.new
       @resource.stubs(:attributes).returns({
         "restype" => 'notify',
         "title"   => 'hello'
       })
       @resource.stubs(:param_names).returns([])
 
       @resource.to_resource(scope).should be_a(Puppet::Parser::Resource)
 
     end
   end
 end
diff --git a/spec/unit/rails_spec.rb b/spec/unit/rails_spec.rb
index 24248e622..02b54efef 100755
--- a/spec/unit/rails_spec.rb
+++ b/spec/unit/rails_spec.rb
@@ -1,324 +1,314 @@
 #!/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?
-
+describe Puppet::Rails, "when initializing any connection", :if => Puppet.features.rails? do
   before do
     Puppet.settings.stubs(:use)
     @logger = mock 'logger'
     @logger.stub_everything
     Logger.stubs(:new).returns(@logger)
 
     ActiveRecord::Base.stubs(:logger).returns(@logger)
     ActiveRecord::Base.stubs(:connected?).returns(false)
   end
 
   it "should use settings" do
     Puppet.settings.expects(:use).with(:main, :rails, :master)
 
     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).returns({})
 
     Puppet::Rails.connect
   end
 
   describe "ActiveRecord Version" do
     it "should set ActiveRecord::Base.allow_concurrency if ActiveRecord is 2.1" do
       Puppet::Util.stubs(:activerecord_version).returns(2.1)
       ActiveRecord::Base.expects(:allow_concurrency=).with(true)
 
       Puppet::Rails.connect
     end
 
     it "should not set ActiveRecord::Base.allow_concurrency if ActiveRecord is >= 2.2" do
       Puppet::Util.stubs(:activerecord_version).returns(2.2)
       ActiveRecord::Base.expects(:allow_concurrency=).never
 
       Puppet::Rails.connect
     end
   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).returns({})
     ActiveRecord::Base.expects(:establish_connection)
 
     Puppet::Rails.connect
   end
 end
 
-describe Puppet::Rails, "when initializing a sqlite3 connection" do
-  confine "Cannot test without ActiveRecord" => Puppet.features.rails?
-
+describe Puppet::Rails, "when initializing a sqlite3 connection", :if => Puppet.features.rails? do
   it "should provide the adapter, log_level, and database 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",
       :database  => "testlocation"
     }
   end
 end
 
-describe Puppet::Rails, "when initializing a mysql connection" do
-  confine "Cannot test without ActiveRecord" => Puppet.features.rails?
-
+describe Puppet::Rails, "when initializing a mysql connection", :if => Puppet.features.rails? do
   it "should provide the adapter, log_level, and host, port, username, password, database, and reconnect 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(:dbport).returns("")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 45).to_s)
     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",
       :pool => pool_size,
       :database => "testname",
       :reconnect => true
     }
   end
 
   it "should provide the adapter, log_level, and host, port, username, password, database, socket, connections, and reconnect 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(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 12).to_s)
     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",
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
       :reconnect => true
     }
   end
 
   it "should provide the adapter, log_level, and host, port, username, password, database, socket, and connections 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(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 23).to_s)
     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",
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
       :reconnect => true
     }
   end
 
   it "should not provide the pool if dbconnections is 0, '0', or ''" 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(:dbport).returns("9999")
     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.settings.stubs(:value).with(:dbconnections).returns(0)
     Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
     Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('')
     Puppet::Rails.database_arguments.should_not be_include(:pool)
   end
 end
 
-describe Puppet::Rails, "when initializing a postgresql connection" do
-  confine "Cannot test without ActiveRecord" => Puppet.features.rails?
-
+describe Puppet::Rails, "when initializing a postgresql connection", :if => Puppet.features.rails? do
   it "should provide the adapter, log_level, and host, port, username, password, connections, and database arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("postgresql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 200).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "postgresql",
       :log_level => "testlevel",
       :host => "testserver",
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :reconnect => true
     }
   end
 
   it "should provide the adapter, log_level, and host, port, username, password, database, connections, and socket arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("postgresql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 122).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "postgresql",
       :log_level => "testlevel",
       :host => "testserver",
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
       :reconnect => true
     }
   end
 
   it "should not provide the pool if dbconnections is 0, '0', or ''" 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(:dbport).returns("9999")
     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.settings.stubs(:value).with(:dbconnections).returns(0)
     Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
     Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('')
     Puppet::Rails.database_arguments.should_not be_include(:pool)
   end
 end
 
-describe Puppet::Rails, "when initializing an Oracle connection" do
-  confine "Cannot test without ActiveRecord" => Puppet.features.rails?
-
+describe Puppet::Rails, "when initializing an Oracle connection", :if => Puppet.features.rails? do
   it "should provide the adapter, log_level, and username, password, and database arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("oracle_enhanced")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 123).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "oracle_enhanced",
       :log_level => "testlevel",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :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("oracle_enhanced")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 124).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "oracle_enhanced",
       :log_level => "testlevel",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname"
     }
   end
 
   it "should not provide the pool if dbconnections is 0, '0', or ''" 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(:dbport).returns("9999")
     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.settings.stubs(:value).with(:dbconnections).returns(0)
     Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
     Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('')
     Puppet::Rails.database_arguments.should_not be_include(:pool)
   end
 end
diff --git a/spec/unit/relationship_spec.rb b/spec/unit/relationship_spec.rb
index 4586cd0f3..9ce6c56e7 100755
--- a/spec/unit/relationship_spec.rb
+++ b/spec/unit/relationship_spec.rb
@@ -1,236 +1,232 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-11-1.
 #  Copyright (c) 2006. All rights reserved.
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/relationship'
 
 describe Puppet::Relationship do
   before do
     @edge = Puppet::Relationship.new(:a, :b)
   end
 
   it "should have a :source attribute" do
     @edge.should respond_to(:source)
   end
 
   it "should have a :target attribute" do
     @edge.should respond_to(:target)
   end
 
   it "should have a :callback attribute" do
     @edge.callback = :foo
     @edge.callback.should == :foo
   end
 
   it "should have an :event attribute" do
     @edge.event = :NONE
     @edge.event.should == :NONE
   end
 
   it "should require a callback if a non-NONE event is specified" do
     proc { @edge.event = :something }.should raise_error(ArgumentError)
   end
 
   it "should have a :label attribute" do
     @edge.should respond_to(:label)
   end
 
   it "should provide a :ref method that describes the edge" do
     @edge = Puppet::Relationship.new("a", "b")
     @edge.ref.should == "a => b"
   end
 
   it "should be able to produce a label as a hash with its event and callback" do
     @edge.callback = :foo
     @edge.event = :bar
 
     @edge.label.should == {:callback => :foo, :event => :bar}
   end
 
   it "should work if nil options are provided" do
     lambda { Puppet::Relationship.new("a", "b", nil) }.should_not raise_error
   end
 end
 
 describe Puppet::Relationship, " when initializing" do
   before do
     @edge = Puppet::Relationship.new(:a, :b)
   end
 
   it "should use the first argument as the source" do
     @edge.source.should == :a
   end
 
   it "should use the second argument as the target" do
     @edge.target.should == :b
   end
 
   it "should set the rest of the arguments as the event and callback" do
     @edge = Puppet::Relationship.new(:a, :b, :callback => :foo, :event => :bar)
     @edge.callback.should == :foo
     @edge.event.should == :bar
   end
 
   it "should accept events specified as strings" do
     @edge = Puppet::Relationship.new(:a, :b, "event" => :NONE)
     @edge.event.should == :NONE
   end
 
   it "should accept callbacks specified as strings" do
     @edge = Puppet::Relationship.new(:a, :b, "callback" => :foo)
     @edge.callback.should == :foo
   end
 end
 
 describe Puppet::Relationship, " when matching edges with no specified event" do
   before do
     @edge = Puppet::Relationship.new(:a, :b)
   end
 
   it "should not match :NONE" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should not match :ALL_EVENTS" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should not match any other events" do
     @edge.should_not be_match(:whatever)
   end
 end
 
 describe Puppet::Relationship, " when matching edges with :NONE as the event" do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :NONE)
   end
   it "should not match :NONE" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should not match :ALL_EVENTS" do
     @edge.should_not be_match(:ALL_EVENTS)
   end
 
   it "should not match other events" do
     @edge.should_not be_match(:yayness)
   end
 end
 
 describe Puppet::Relationship, " when matching edges with :ALL as the event" do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :ALL_EVENTS, :callback => :whatever)
   end
 
   it "should not match :NONE" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should match :ALL_EVENTS" do
     @edge.should be_match(:ALLEVENTS)
   end
 
   it "should match all other events" do
     @edge.should be_match(:foo)
   end
 end
 
 describe Puppet::Relationship, " when matching edges with a non-standard event" do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
   end
 
   it "should not match :NONE" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should not match :ALL_EVENTS" do
     @edge.should_not be_match(:ALL_EVENTS)
   end
 
   it "should match events with the same name" do
     @edge.should be_match(:random)
   end
 end
 
-describe Puppet::Relationship, "when converting to pson" do
-  confine "Missing 'pson' library" => Puppet.features.pson?
-
+describe Puppet::Relationship, "when converting to pson", :if => Puppet.features.pson? do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
   end
 
   it "should store the stringified source as the source in the data" do
     PSON.parse(@edge.to_pson)["source"].should == "a"
   end
 
   it "should store the stringified target as the target in the data" do
     PSON.parse(@edge.to_pson)['target'].should == "b"
   end
 
   it "should store the psonified event as the event in the data" do
     PSON.parse(@edge.to_pson)["event"].should == "random"
   end
 
   it "should not store an event when none is set" do
     @edge.event = nil
     PSON.parse(@edge.to_pson)["event"].should be_nil
   end
 
   it "should store the psonified callback as the callback in the data" do
     @edge.callback = "whatever"
     PSON.parse(@edge.to_pson)["callback"].should == "whatever"
   end
 
   it "should not store a callback when none is set in the edge" do
     @edge.callback = nil
     PSON.parse(@edge.to_pson)["callback"].should be_nil
   end
 end
 
-describe Puppet::Relationship, "when converting from pson" do
-  confine "Missing 'pson' library" => Puppet.features.pson?
-
+describe Puppet::Relationship, "when converting from pson", :if => Puppet.features.pson? do
   before do
     @event = "random"
     @callback = "whatever"
     @data = {
       "source" => "mysource",
       "target" => "mytarget",
       "event" => @event,
       "callback" => @callback
     }
     @pson = {
       "type" => "Puppet::Relationship",
       "data" => @data
     }
   end
 
   def pson_result_should
     Puppet::Relationship.expects(:new).with { |*args| yield args }
   end
 
   it "should be extended with the PSON utility module" do
     Puppet::Relationship.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
   end
 
   # LAK:NOTE For all of these tests, we convert back to the edge so we can
   # trap the actual data structure then.
   it "should pass the source in as the first argument" do
     Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget").source.should == "mysource"
   end
 
   it "should pass the target in as the second argument" do
     Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget").target.should == "mytarget"
   end
 
   it "should pass the event as an argument if it's provided" do
     Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event.should == "myevent"
   end
 
   it "should pass the callback as an argument if it's provided" do
     Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback.should == "mycallback"
   end
 end
diff --git a/spec/unit/resource/catalog_spec.rb b/spec/unit/resource/catalog_spec.rb
index 2b6beb5e9..942721464 100755
--- a/spec/unit/resource/catalog_spec.rb
+++ b/spec/unit/resource/catalog_spec.rb
@@ -1,1078 +1,1074 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Resource::Catalog, "when compiling" do
 
   before do
     @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should be an Expirer" do
     Puppet::Resource::Catalog.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
   end
 
   it "should always be expired if it's not applying" do
     @catalog = Puppet::Resource::Catalog.new("host")
     @catalog.expects(:applying?).returns false
     @catalog.should be_dependent_data_expired(Time.now)
   end
 
   it "should not be expired if it's applying and the timestamp is late enough" do
     @catalog = Puppet::Resource::Catalog.new("host")
     @catalog.expire
     @catalog.expects(:applying?).returns true
     @catalog.should_not be_dependent_data_expired(Time.now)
   end
 
   it "should be able to write its list of classes to the class file" do
     @catalog = Puppet::Resource::Catalog.new("host")
 
     @catalog.add_class "foo", "bar"
 
     Puppet.settings.expects(:value).with(:classfile).returns "/class/file"
 
     fh = mock 'filehandle'
     File.expects(:open).with("/class/file", "w").yields fh
 
     fh.expects(:puts).with "foo\nbar"
 
     @catalog.write_class_file
   end
 
   it "should have a client_version attribute" do
     @catalog = Puppet::Resource::Catalog.new("host")
     @catalog.client_version = 5
     @catalog.client_version.should == 5
   end
 
   it "should have a server_version attribute" do
     @catalog = Puppet::Resource::Catalog.new("host")
     @catalog.server_version = 5
     @catalog.server_version.should == 5
   end
 
   describe "when compiling" do
     it "should accept tags" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one")
       config.tags.should == %w{one}
     end
 
     it "should accept multiple tags at once" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one", "two")
       config.tags.should == %w{one two}
     end
 
     it "should convert all tags to strings" do
       config = Puppet::Resource::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::Resource::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::Resource::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::Resource::Catalog.new("mynode")
       config.add_class("one")
       config.tags.should == %w{one}
     end
   end
 
   describe "when extracting transobjects" do
 
     def mkscope
       @node = Puppet::Node.new("mynode")
       @compiler = Puppet::Parser::Compiler.new(@node)
 
       # XXX This is ridiculous.
       @compiler.send(:evaluate_main)
       @scope = @compiler.topscope
     end
 
     def mkresource(type, name)
       Puppet::Parser::Resource.new(type, name, :source => @source, :scope => @scope)
     end
 
     it "should fail if no 'main' stage can be found" do
       lambda { Puppet::Resource::Catalog.new("mynode").extract }.should raise_error(Puppet::DevError)
     end
 
     it "should warn if any non-main stages are present" do
       config = Puppet::Resource::Catalog.new("mynode")
 
       @scope = mkscope
       @source = mock 'source'
 
       main = mkresource("stage", "main")
       config.add_resource(main)
 
       other = mkresource("stage", "other")
       config.add_resource(other)
 
       Puppet.expects(:warning)
 
       config.extract
     end
 
     it "should always create a TransBucket for the 'main' stage" do
       config = Puppet::Resource::Catalog.new("mynode")
 
       @scope = mkscope
       @source = mock 'source'
 
       main = mkresource("stage", "main")
       config.add_resource(main)
 
       result = config.extract
       result.type.should == "Stage"
       result.name.should == "main"
     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::Resource::Catalog.new("mynode")
 
       @scope = mkscope
       @scope.stubs(:tags).returns([])
       @source = mock 'source'
 
       # Create our scopes.
       top = mkresource "stage", "main"
 
       config.add_resource top
       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
 
       # 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 " when converting to a Puppet::Resource catalog" do
     before do
       @original = Puppet::Resource::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_resource
     end
 
     it "should copy over the version" do
       @original.version = "foo"
       @original.to_resource.version.should == "foo"
     end
 
     it "should convert parser resources to plain resources" do
       resource = Puppet::Parser::Resource.new(:file, "foo", :scope => stub("scope", :environment => nil, :namespaces => nil), :source => stub("source"))
       catalog = Puppet::Resource::Catalog.new("whev")
       catalog.add_resource(resource)
       new = catalog.to_resource
       new.resource(:file, "foo").class.should == Puppet::Resource
     end
 
     it "should add all resources as Puppet::Resource instances" do
       @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Resource) }
     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
   end
 
   describe "when converting to a RAL catalog" do
     before do
       @original = Puppet::Resource::Catalog.new("mynode")
       @original.tag(*%w{one two three})
       @original.add_class *%w{four five six}
 
       @top            = Puppet::Resource.new :class, 'top'
       @topobject      = Puppet::Resource.new :file, @basepath+'/topobject'
       @middle         = Puppet::Resource.new :class, 'middle'
       @middleobject   = Puppet::Resource.new :file, @basepath+'/middleobject'
       @bottom         = Puppet::Resource.new :class, 'bottom'
       @bottomobject   = Puppet::Resource.new :file, @basepath+'/bottomobject'
 
       @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
 
     # This tests #931.
     it "should not lose track of resources whose names vary" do
       changer = Puppet::TransObject.new 'changer', 'test'
 
       config = Puppet::Resource::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_ral).returns(resource)
 
       newconfig = nil
 
       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 "when filtering" do
     before :each do
       @original = Puppet::Resource::Catalog.new("mynode")
       @original.tag(*%w{one two three})
       @original.add_class *%w{four five six}
 
       @r1 = stub_everything 'r1', :ref => "File[/a]"
       @r1.stubs(:respond_to?).with(:ref).returns(true)
       @r1.stubs(:dup).returns(@r1)
       @r1.stubs(:is_a?).returns(Puppet::Resource).returns(true)
 
       @r2 = stub_everything 'r2', :ref => "File[/b]"
       @r2.stubs(:respond_to?).with(:ref).returns(true)
       @r2.stubs(:dup).returns(@r2)
       @r2.stubs(:is_a?).returns(Puppet::Resource).returns(true)
 
       @resources = [@r1,@r2]
 
       @original.add_resource(@r1,@r2)
     end
 
     it "should transform the catalog to a resource catalog" do
       @original.expects(:to_catalog).with { |h,b| h == :to_resource }
 
       @original.filter
     end
 
     it "should scan each catalog resource in turn and apply filtering block" do
       @resources.each { |r| r.expects(:test?) }
       @original.filter do |r|
         r.test?
       end
     end
 
     it "should filter out resources which produce true when the filter block is evaluated" do
       @original.filter do |r|
         r == @r1
       end.resource("File[/a]").should be_nil
     end
 
     it "should not consider edges against resources that were filtered out" do
       @original.add_edge(@r1,@r2)
       @original.filter do |r|
         r == @r1
       end.edge(@r1,@r2).should be_empty
     end
   end
 
   describe "when functioning as a resource container" do
     before do
       @catalog = Puppet::Resource::Catalog.new("host")
       @one = Puppet::Type.type(:notify).new :name => "one"
       @two = Puppet::Type.type(:notify).new :name => "two"
       @dupe = Puppet::Type.type(:notify).new :name => "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 add resources to the relationship graph if it exists" do
       relgraph = @catalog.relationship_graph
       @catalog.add_resource @one
       relgraph.should be_vertex(@one)
     end
 
     it "should yield added resources if a block is provided" do
       yielded = []
       @catalog.add_resource(@one, @two) { |r| yielded << r }
       yielded.length.should == 2
     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 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("notify", "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("notify[one]", nil).should equal(@one)
     end
 
     it "should not allow two resources with the same resource reference" do
       @catalog.add_resource(@one)
 
       proc { @catalog.add_resource(@dupe) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     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::Resource::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("notify", "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("notify", "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 create aliases for resources isomorphic resources whose names do not match their titles" do
       resource = Puppet::Type::File.new(:title => "testing", :path => @basepath+"/something")
 
       @catalog.add_resource(resource)
 
       @catalog.resource(:file, @basepath+"/something").should equal(resource)
     end
 
     it "should not create aliases for resources non-isomorphic resources whose names do not match their titles" do
       resource = Puppet::Type.type(:exec).new(:title => "testing", :command => "echo", :path => %w{/bin /usr/bin /usr/local/bin})
 
       @catalog.add_resource(resource)
 
       # Yay, I've already got a 'should' method
       @catalog.resource(:exec, "echo").object_id.should == nil.object_id
     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("notify", "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(:notify, "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(:notify, "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("notify", "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).new :path => @basepath+"/something", :title => "other", :content => "blah"
       resource.expects(:isomorphic?).returns(true)
       @catalog.add_resource(resource)
       @catalog.resource(:file, "other").should equal(resource)
       @catalog.resource(:file, @basepath+"/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).new :path => @basepath+"/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.
       raise "Aliased non-isomorphic resource" if @catalog.resource(:file, resource.name)
     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, :title => "/yay", :[] => "/yay"
       Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
       @catalog.create_resource :file, args
       @catalog.resource("File[/yay]").should equal(resource)
     end
   end
 
   describe "when applying" do
     before :each do
       @catalog = Puppet::Resource::Catalog.new("host")
 
       @transaction = mock 'transaction'
       Puppet::Transaction.stubs(:new).returns(@transaction)
       @transaction.stubs(:evaluate)
       @transaction.stubs(:add_times)
 
       Puppet.settings.stubs(:use)
     end
 
     it "should create and evaluate a transaction" do
       @transaction.expects(:evaluate)
       @catalog.apply
     end
 
     it "should provide the catalog retrieval time to the transaction" do
       @catalog.retrieval_duration = 5
       @transaction.expects(:add_times).with(:config_retrieval => 5)
       @catalog.apply
     end
 
     it "should use a retrieval time of 0 if none is set in the catalog" do
       @catalog.retrieval_duration = nil
       @transaction.expects(:add_times).with(:config_retrieval => 0)
       @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 being a host catalog" do
       @catalog.host_config.should be_true
     end
 
     it "should be able to be set to a non-host_config" do
       @catalog.host_config = false
       @catalog.host_config.should be_false
     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
 
     it "should expire cached data in the resources both before and after the transaction" do
       @catalog.expects(:expire).times(2)
       @catalog.apply
     end
 
     describe "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 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 "non-host catalogs" do
 
       before do
         @catalog.host_config = false
       end
 
       it "should never send reports" do
         Puppet[:report] = true
         Puppet[:summarize] = true
         @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 "when creating a relationship graph" do
     before do
       Puppet::Type.type(:component)
       @catalog = Puppet::Resource::Catalog.new("host")
       @compone = Puppet::Type::Component.new :name => "one"
       @comptwo = Puppet::Type::Component.new :name => "two", :require => "Class[one]"
       @file = Puppet::Type.type(:file)
       @one = @file.new :path => @basepath+"/one"
       @two = @file.new :path => @basepath+"/two"
       @sub = @file.new :path => @basepath+"/two/subdir"
       @catalog.add_edge @compone, @one
       @catalog.add_edge @comptwo, @two
 
       @three = @file.new :path => @basepath+"/three"
       @four = @file.new :path => @basepath+"/four", :require => "File[#{@basepath}/three]"
       @five = @file.new :path => @basepath+"/five"
       @catalog.add_resource @compone, @comptwo, @one, @two, @three, @four, @five, @sub
 
       @relationships = @catalog.relationship_graph
     end
 
     it "should be able to create a relationship graph" do
       @relationships.should be_instance_of(Puppet::SimpleGraph)
     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 add automatic relationships to the relationship graph" do
       @relationships.edge?(@two, @sub).should be_true
     end
 
     it "should get removed when the catalog is cleaned up" do
       @relationships.expects(:clear)
       @catalog.clear
       @catalog.instance_variable_get("@relationship_graph").should be_nil
     end
 
     it "should write :relationships and :expanded_relationships graph files if the catalog is a host catalog" do
       @catalog.clear
       graph = Puppet::SimpleGraph.new
       Puppet::SimpleGraph.expects(:new).returns graph
 
       graph.expects(:write_graph).with(:relationships)
       graph.expects(:write_graph).with(:expanded_relationships)
 
       @catalog.host_config = true
 
       @catalog.relationship_graph
     end
 
     it "should not write graph files if the catalog is not a host catalog" do
       @catalog.clear
       graph = Puppet::SimpleGraph.new
       Puppet::SimpleGraph.expects(:new).returns graph
 
       graph.expects(:write_graph).never
 
       @catalog.host_config = false
 
       @catalog.relationship_graph
     end
 
     it "should create a new relationship graph after clearing the old one" do
       @relationships.expects(:clear)
       @catalog.clear
       @catalog.relationship_graph.should be_instance_of(Puppet::SimpleGraph)
     end
 
     it "should remove removed resources from the relationship graph if it exists" do
       @catalog.remove_resource(@one)
       @catalog.relationship_graph.vertex?(@one).should be_false
     end
   end
 
   describe "when writing dot files" do
     before do
       @catalog = Puppet::Resource::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
 
     after do
       Puppet.settings.clear
     end
   end
 
   describe "when indirecting" do
     before do
       @real_indirection = Puppet::Resource::Catalog.indirection
 
       @indirection = stub 'indirection', :name => :catalog
 
       Puppet::Util::Cacher.expire
     end
 
     it "should redirect to the indirection for retrieval" do
       Puppet::Resource::Catalog.stubs(:indirection).returns(@indirection)
       @indirection.expects(:find)
       Puppet::Resource::Catalog.find(:myconfig)
     end
 
     it "should use the value of the 'catalog_terminus' setting to determine its terminus class" do
       # Puppet only checks the terminus setting the first time you ask
       # so this returns the object to the clean state
       # at the expense of making this test less pure
       Puppet::Resource::Catalog.indirection.reset_terminus_class
 
       Puppet.settings[:catalog_terminus] = "rest"
       Puppet::Resource::Catalog.indirection.terminus_class.should == :rest
     end
 
     it "should allow the terminus class to be set manually" do
       Puppet::Resource::Catalog.indirection.terminus_class = :rest
       Puppet::Resource::Catalog.indirection.terminus_class.should == :rest
     end
 
     after do
       Puppet::Util::Cacher.expire
       @real_indirection.reset_terminus_class
     end
   end
 
   describe "when converting to yaml" do
     before do
       @catalog = Puppet::Resource::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 "when converting from yaml" do
     before do
       @catalog = Puppet::Resource::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::Resource::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
 end
 
-describe Puppet::Resource::Catalog, "when converting to pson" do
-  confine "Missing 'pson' library" => Puppet.features.pson?
-
+describe Puppet::Resource::Catalog, "when converting to pson", :if => Puppet.features.pson? do
   before do
     @catalog = Puppet::Resource::Catalog.new("myhost")
   end
 
   def pson_output_should
     @catalog.class.expects(:pson_create).with { |hash| yield hash }.returns(:something)
   end
 
   # LAK:NOTE For all of these tests, we convert back to the resource so we can
   # trap the actual data structure then.
   it "should set its document_type to 'Catalog'" do
     pson_output_should { |hash| hash['document_type'] == "Catalog" }
 
     PSON.parse @catalog.to_pson
   end
 
   it "should set its data as a hash" do
     pson_output_should { |hash| hash['data'].is_a?(Hash) }
     PSON.parse @catalog.to_pson
   end
 
   [:name, :version, :tags, :classes].each do |param|
     it "should set its #{param} to the #{param} of the resource" do
       @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
 
       pson_output_should { |hash| hash['data'][param.to_s] == @catalog.send(param) }
       PSON.parse @catalog.to_pson
     end
   end
 
   it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
     one = stub 'one', :to_pson_data_hash => "one_resource", :ref => "Foo[one]"
     two = stub 'two', :to_pson_data_hash => "two_resource", :ref => "Foo[two]"
 
     @catalog.add_resource(one)
     @catalog.add_resource(two)
 
     # TODO this should really guarantee sort order
     PSON.parse(@catalog.to_pson,:create_additions => false)['data']['resources'].sort.should == ["one_resource", "two_resource"].sort
 
   end
 
   it "should convert its edges to a PSON-encoded array and store it as the 'edges' data" do
     one   = stub 'one',   :to_pson_data_hash => "one_resource",   :ref => 'Foo[one]'
     two   = stub 'two',   :to_pson_data_hash => "two_resource",   :ref => 'Foo[two]'
     three = stub 'three', :to_pson_data_hash => "three_resource", :ref => 'Foo[three]'
 
     @catalog.add_edge(one, two)
     @catalog.add_edge(two, three)
 
     @catalog.edge(one, two  ).expects(:to_pson_data_hash).returns "one_two_pson"
     @catalog.edge(two, three).expects(:to_pson_data_hash).returns "two_three_pson"
 
     PSON.parse(@catalog.to_pson,:create_additions => false)['data']['edges'].sort.should == %w{one_two_pson two_three_pson}.sort
   end
 end
 
-describe Puppet::Resource::Catalog, "when converting from pson" do
-  confine "Missing 'pson' library" => Puppet.features.pson?
-
+describe Puppet::Resource::Catalog, "when converting from pson", :if => Puppet.features.pson? do
   def pson_result_should
     Puppet::Resource::Catalog.expects(:new).with { |hash| yield hash }
   end
 
   before do
     @data = {
       'name' => "myhost"
     }
     @pson = {
       'document_type' => 'Puppet::Resource::Catalog',
       'data' => @data,
       'metadata' => {}
     }
 
     @catalog = Puppet::Resource::Catalog.new("myhost")
     Puppet::Resource::Catalog.stubs(:new).returns @catalog
   end
 
   it "should be extended with the PSON utility module" do
     Puppet::Resource::Catalog.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
   end
 
   it "should create it with the provided name" do
     Puppet::Resource::Catalog.expects(:new).with('myhost').returns @catalog
     PSON.parse @pson.to_pson
   end
 
   it "should set the provided version on the catalog if one is set" do
     @data['version'] = 50
     PSON.parse @pson.to_pson
     @catalog.version.should == @data['version']
   end
 
   it "should set any provided tags on the catalog" do
     @data['tags'] = %w{one two}
     PSON.parse @pson.to_pson
     @catalog.tags.should == @data['tags']
   end
 
   it "should set any provided classes on the catalog" do
     @data['classes'] = %w{one two}
     PSON.parse @pson.to_pson
     @catalog.classes.should == @data['classes']
   end
 
   it 'should convert the resources list into resources and add each of them' do
     @data['resources'] = [Puppet::Resource.new(:file, "/foo"), Puppet::Resource.new(:file, "/bar")]
 
     @catalog.expects(:add_resource).times(2).with { |res| res.type == "File" }
     PSON.parse @pson.to_pson
   end
 
   it 'should convert resources even if they do not include "type" information' do
     @data['resources'] = [Puppet::Resource.new(:file, "/foo")]
 
     @data['resources'][0].expects(:to_pson).returns '{"title":"/foo","tags":["file"],"type":"File"}'
 
     @catalog.expects(:add_resource).with { |res| res.type == "File" }
 
     PSON.parse @pson.to_pson
   end
 
   it 'should convert the edges list into edges and add each of them' do
     one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
     two = Puppet::Relationship.new("tsource", "ttarget", :event => "two", :callback => "refresh")
 
     @data['edges'] = [one, two]
 
     @catalog.stubs(:resource).returns("eh")
 
     @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
     @catalog.expects(:add_edge).with { |edge| edge.event == "two" }
 
     PSON.parse @pson.to_pson
   end
 
   it "should be able to convert relationships that do not include 'type' information" do
     one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
     one.expects(:to_pson).returns "{\"event\":\"one\",\"callback\":\"refresh\",\"source\":\"osource\",\"target\":\"otarget\"}"
 
     @data['edges'] = [one]
 
     @catalog.stubs(:resource).returns("eh")
 
     @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
 
     PSON.parse @pson.to_pson
   end
 
   it "should set the source and target for each edge to the actual resource" do
     edge = Puppet::Relationship.new("source", "target")
 
     @data['edges'] = [edge]
 
     @catalog.expects(:resource).with("source").returns("source_resource")
     @catalog.expects(:resource).with("target").returns("target_resource")
 
     @catalog.expects(:add_edge).with { |edge| edge.source == "source_resource" and edge.target == "target_resource" }
 
     PSON.parse @pson.to_pson
   end
 
   it "should fail if the source resource cannot be found" do
     edge = Puppet::Relationship.new("source", "target")
 
     @data['edges'] = [edge]
 
     @catalog.expects(:resource).with("source").returns(nil)
     @catalog.stubs(:resource).with("target").returns("target_resource")
 
     lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
   end
 
   it "should fail if the target resource cannot be found" do
     edge = Puppet::Relationship.new("source", "target")
 
     @data['edges'] = [edge]
 
     @catalog.stubs(:resource).with("source").returns("source_resource")
     @catalog.expects(:resource).with("target").returns(nil)
 
     lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
   end
 
   describe "#title_key_for_ref" do
     it "should parse a resource ref string into a pair" do
       @catalog.title_key_for_ref("Title[name]").should == ["Title", "name"]
     end
     it "should parse a resource ref string into a pair, even if there's a newline inside the name" do
       @catalog.title_key_for_ref("Title[na\nme]").should == ["Title", "na\nme"]
     end
   end
 end
diff --git a/spec/unit/resource_spec.rb b/spec/unit/resource_spec.rb
index e65e8a13a..877b6b6b0 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -1,782 +1,778 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/resource'
 
 describe Puppet::Resource do
 
   before do
     @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
   end
 
   [:catalog, :file, :line].each do |attr|
     it "should have an #{attr} attribute" do
       resource = Puppet::Resource.new("file", "/my/file")
       resource.should respond_to(attr)
       resource.should respond_to(attr.to_s + "=")
     end
   end
 
   it "should have a :title attribute" do
     Puppet::Resource.new(:user, "foo").title.should == "foo"
   end
 
   it "should require the type and title" do
     lambda { Puppet::Resource.new }.should raise_error(ArgumentError)
   end
 
   it "should canonize types to capitalized strings" do
     Puppet::Resource.new(:user, "foo").type.should == "User"
   end
 
   it "should canonize qualified types so all strings are capitalized" do
     Puppet::Resource.new("foo::bar", "foo").type.should == "Foo::Bar"
   end
 
   it "should tag itself with its type" do
     Puppet::Resource.new("file", "/f").should be_tagged("file")
   end
 
   it "should tag itself with its title if the title is a valid tag" do
     Puppet::Resource.new("user", "bar").should be_tagged("bar")
   end
 
   it "should not tag itself with its title if the title is a not valid tag" do
     Puppet::Resource.new("file", "/bar").should_not be_tagged("/bar")
   end
 
   it "should allow setting of attributes" do
     Puppet::Resource.new("file", "/bar", :file => "/foo").file.should == "/foo"
     Puppet::Resource.new("file", "/bar", :exported => true).should be_exported
   end
 
   it "should set its type to 'Class' and its title to the passed title if the passed type is :component and the title has no square brackets in it" do
     ref = Puppet::Resource.new(:component, "foo")
     ref.type.should == "Class"
     ref.title.should == "Foo"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is :component and the title contains square brackets" do
     ref = Puppet::Resource.new(:component, "foo::bar[yay]")
     ref.type.should == "Foo::Bar"
     ref.title.should == "yay"
   end
 
   it "should set the type to 'Class' if it is nil and the title contains no square brackets" do
     ref = Puppet::Resource.new(nil, "yay")
     ref.type.should == "Class"
     ref.title.should == "Yay"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains square brackets" do
     ref = Puppet::Resource.new(nil, "foo::bar[yay]")
     ref.type.should == "Foo::Bar"
     ref.title.should == "yay"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains nested square brackets" do
     ref = Puppet::Resource.new(nil, "foo::bar[baz[yay]]")
     ref.type.should == "Foo::Bar"
     ref.title.should =="baz[yay]"
   end
 
   it "should interpret the type as a reference and assign appropriately if the title is nil and the type contains square brackets" do
     ref = Puppet::Resource.new("foo::bar[baz]")
     ref.type.should == "Foo::Bar"
     ref.title.should =="baz"
   end
 
   it "should be able to extract its information from a Puppet::Type instance" do
     ral = Puppet::Type.type(:file).new :path => @basepath+"/foo"
     ref = Puppet::Resource.new(ral)
     ref.type.should == "File"
     ref.title.should == @basepath+"/foo"
   end
 
 
   it "should fail if the title is nil and the type is not a valid resource reference string" do
     lambda { Puppet::Resource.new("foo") }.should raise_error(ArgumentError)
   end
 
   it "should fail if the title is a hash and the type is not a valid resource reference string" do
     lambda { Puppet::Resource.new({:type => "foo", :title => "bar"}) }.should raise_error(ArgumentError,
       'Puppet::Resource.new does not take a hash as the first argument. Did you mean ("foo", "bar") ?'
     )
   end
 
   it "should be able to produce a backward-compatible reference array" do
     Puppet::Resource.new("foobar", "/f").to_trans_ref.should == %w{Foobar /f}
   end
 
   it "should be taggable" do
     Puppet::Resource.ancestors.should be_include(Puppet::Util::Tagging)
   end
 
   it "should have an 'exported' attribute" do
     resource = Puppet::Resource.new("file", "/f")
     resource.exported = true
     resource.exported.should == true
     resource.should be_exported
   end
 
   it "should support an environment attribute" do
     Puppet::Resource.new("file", "/my/file", :environment => :foo).environment.name.should == :foo
   end
 
   describe "and munging its type and title" do
     describe "when modeling a builtin resource" do
       it "should be able to find the resource type" do
         Puppet::Resource.new("file", "/my/file").resource_type.should equal(Puppet::Type.type(:file))
       end
 
       it "should set its type to the capitalized type name" do
         Puppet::Resource.new("file", "/my/file").type.should == "File"
       end
     end
 
     describe "when modeling a defined resource" do
       describe "that exists" do
         before do
           @type = Puppet::Resource::Type.new(:definition, "foo::bar")
           Puppet::Node::Environment.new.known_resource_types.add @type
         end
 
         it "should set its type to the capitalized type name" do
           Puppet::Resource.new("foo::bar", "/my/file").type.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
           Puppet::Resource.new("foo::bar", "/my/file").resource_type.should equal(@type)
         end
 
         it "should set its title to the provided title" do
           Puppet::Resource.new("foo::bar", "/my/file").title.should == "/my/file"
         end
       end
 
       describe "that does not exist" do
         it "should set its resource type to the capitalized resource type name" do
           Puppet::Resource.new("foo::bar", "/my/file").type.should == "Foo::Bar"
         end
       end
     end
 
     describe "when modeling a node" do
       # Life's easier with nodes, because they can't be qualified.
       it "should set its type to 'Node' and its title to the provided title" do
         node = Puppet::Resource.new("node", "foo")
         node.type.should == "Node"
         node.title.should == "foo"
       end
     end
 
     describe "when modeling a class" do
       it "should set its type to 'Class'" do
         Puppet::Resource.new("class", "foo").type.should == "Class"
       end
 
       describe "that exists" do
         before do
           @type = Puppet::Resource::Type.new(:hostclass, "foo::bar")
           Puppet::Node::Environment.new.known_resource_types.add @type
         end
 
         it "should set its title to the capitalized, fully qualified resource type" do
           Puppet::Resource.new("class", "foo::bar").title.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
           Puppet::Resource.new("class", "foo::bar").resource_type.should equal(@type)
         end
       end
 
       describe "that does not exist" do
         it "should set its type to 'Class' and its title to the capitalized provided name" do
           klass = Puppet::Resource.new("class", "foo::bar")
           klass.type.should == "Class"
           klass.title.should == "Foo::Bar"
         end
       end
 
       describe "and its name is set to the empty string" do
         it "should set its title to :main" do
           Puppet::Resource.new("class", "").title.should == :main
         end
 
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
           it "should set its title to :main" do
             @type = Puppet::Resource::Type.new(:hostclass, "")
             Puppet::Node::Environment.new.known_resource_types.add @type
 
             Puppet::Resource.new("class", "").title.should == :main
           end
         end
       end
 
       describe "and its name is set to :main" do
         it "should set its title to :main" do
           Puppet::Resource.new("class", :main).title.should == :main
         end
 
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
           it "should set its title to :main" do
             @type = Puppet::Resource::Type.new(:hostclass, "")
             Puppet::Node::Environment.new.known_resource_types.add @type
 
             Puppet::Resource.new("class", :main).title.should == :main
           end
         end
       end
     end
   end
 
   it "should return nil when looking up resource types that don't exist" do
     Puppet::Resource.new("foobar", "bar").resource_type.should be_nil
   end
 
   it "should not fail when an invalid parameter is used and strict mode is disabled" do
     type = Puppet::Resource::Type.new(:definition, "foobar")
     Puppet::Node::Environment.new.known_resource_types.add type
     resource = Puppet::Resource.new("foobar", "/my/file")
     resource[:yay] = true
   end
 
   it "should be considered equivalent to another resource if their type and title match and no parameters are set" do
     Puppet::Resource.new("file", "/f").should == Puppet::Resource.new("file", "/f")
   end
 
   it "should be considered equivalent to another resource if their type, title, and parameters are equal" do
     Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"}).should == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
   end
 
   it "should not be considered equivalent to another resource if their type and title match but parameters are different" do
     Puppet::Resource.new("file", "/f", :parameters => {:fee => "baz"}).should_not == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
   end
 
   it "should not be considered equivalent to a non-resource" do
     Puppet::Resource.new("file", "/f").should_not == "foo"
   end
 
   it "should not be considered equivalent to another resource if their types do not match" do
     Puppet::Resource.new("file", "/f").should_not == Puppet::Resource.new("exec", "/f")
   end
 
   it "should not be considered equivalent to another resource if their titles do not match" do
     Puppet::Resource.new("file", "/foo").should_not == Puppet::Resource.new("file", "/f")
   end
 
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")
       res.uniqueness_key.should == ["/path"]
       res.ref.should == "File[/path/]"
     end
   end
 
   describe "when running in strict mode" do
     it "should be strict" do
       Puppet::Resource.new("file", "/path", :strict => true).should be_strict
     end
 
     it "should fail if invalid parameters are used" do
       lambda { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.should raise_error
     end
 
     it "should fail if the resource type cannot be resolved" do
       lambda { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.should raise_error
     end
   end
 
   describe "when managing parameters" do
     before do
       @resource = Puppet::Resource.new("file", "/my/file")
     end
 
     it "should correctly detect when provided parameters are not valid for builtin types" do
       Puppet::Resource.new("file", "/my/file").should_not be_valid_parameter("foobar")
     end
 
     it "should correctly detect when provided parameters are valid for builtin types" do
       Puppet::Resource.new("file", "/my/file").should be_valid_parameter("mode")
     end
 
     it "should correctly detect when provided parameters are not valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar")
       Puppet::Node::Environment.new.known_resource_types.add type
       Puppet::Resource.new("foobar", "/my/file").should_not be_valid_parameter("myparam")
     end
 
     it "should correctly detect when provided parameters are valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar", :arguments => {"myparam" => nil})
       Puppet::Node::Environment.new.known_resource_types.add type
       Puppet::Resource.new("foobar", "/my/file").should be_valid_parameter("myparam")
     end
 
     it "should allow setting and retrieving of parameters" do
       @resource[:foo] = "bar"
       @resource[:foo].should == "bar"
     end
 
     it "should allow setting of parameters at initialization" do
       Puppet::Resource.new("file", "/my/file", :parameters => {:foo => "bar"})[:foo].should == "bar"
     end
 
     it "should canonicalize retrieved parameter names to treat symbols and strings equivalently" do
       @resource[:foo] = "bar"
       @resource["foo"].should == "bar"
     end
 
     it "should canonicalize set parameter names to treat symbols and strings equivalently" do
       @resource["foo"] = "bar"
       @resource[:foo].should == "bar"
     end
 
     it "should set the namevar when asked to set the name" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:name] = "bob"
       resource[:myvar].should == "bob"
     end
 
     it "should return the namevar when asked to return the name" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:myvar] = "test"
       resource[:name].should == "test"
     end
 
     it "should be able to set the name for non-builtin types" do
       resource = Puppet::Resource.new(:foo, "bar")
       resource[:name] = "eh"
       lambda { resource[:name] = "eh" }.should_not raise_error
     end
 
     it "should be able to return the name for non-builtin types" do
       resource = Puppet::Resource.new(:foo, "bar")
       resource[:name] = "eh"
       resource[:name].should == "eh"
     end
 
     it "should be able to iterate over parameters" do
       @resource[:foo] = "bar"
       @resource[:fee] = "bare"
       params = {}
       @resource.each do |key, value|
         params[key] = value
       end
       params.should == {:foo => "bar", :fee => "bare"}
     end
 
     it "should include Enumerable" do
       @resource.class.ancestors.should be_include(Enumerable)
     end
 
     it "should have a method for testing whether a parameter is included" do
       @resource[:foo] = "bar"
       @resource.should be_has_key(:foo)
       @resource.should_not be_has_key(:eh)
     end
 
     it "should have a method for providing the list of parameters" do
       @resource[:foo] = "bar"
       @resource[:bar] = "foo"
       keys = @resource.keys
       keys.should be_include(:foo)
       keys.should be_include(:bar)
     end
 
     it "should have a method for providing the number of parameters" do
       @resource[:foo] = "bar"
       @resource.length.should == 1
     end
 
     it "should have a method for deleting parameters" do
       @resource[:foo] = "bar"
       @resource.delete(:foo)
       @resource[:foo].should be_nil
     end
 
     it "should have a method for testing whether the parameter list is empty" do
       @resource.should be_empty
       @resource[:foo] = "bar"
       @resource.should_not be_empty
     end
 
     it "should be able to produce a hash of all existing parameters" do
       @resource[:foo] = "bar"
       @resource[:fee] = "yay"
 
       hash = @resource.to_hash
       hash[:foo].should == "bar"
       hash[:fee].should == "yay"
     end
 
     it "should not provide direct access to the internal parameters hash when producing a hash" do
       hash = @resource.to_hash
       hash[:foo] = "bar"
       @resource[:foo].should be_nil
     end
 
     it "should use the title as the namevar to the hash if no namevar is present" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource.to_hash[:myvar].should == "bob"
     end
 
     it "should set :name to the title if :name is not present for non-builtin types" do
       krt = Puppet::Resource::TypeCollection.new("myenv")
       krt.add Puppet::Resource::Type.new(:definition, :foo)
       resource = Puppet::Resource.new :foo, "bar"
       resource.stubs(:known_resource_types).returns krt
       resource.to_hash[:name].should == "bar"
     end
   end
 
   describe "when serializing" do
     before do
       @resource = Puppet::Resource.new("file", "/my/file")
       @resource["one"] = "test"
       @resource["two"] = "other"
     end
 
     it "should be able to be dumped to yaml" do
       proc { YAML.dump(@resource) }.should_not raise_error
     end
 
     it "should produce an equivalent yaml object" do
       text = YAML.dump(@resource)
 
       newresource = YAML.load(text)
       newresource.title.should == @resource.title
       newresource.type.should == @resource.type
       %w{one two}.each do |param|
         newresource[param].should == @resource[param]
       end
     end
   end
 
   describe "when converting to a RAL resource" do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", @basepath+"/my/file")
       result = resource.to_ral
       result.should be_instance_of(Puppet::Type.type(:file))
       result[:path].should == @basepath+"/my/file"
     end
 
     it "should convert to a component instance if the resource type is not of a builtin type" do
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
       result.should be_instance_of(Puppet::Type.type(:component))
       result.title.should == "Foobar[somename]"
     end
   end
 
   it "should be able to convert itself to Puppet code" do
     Puppet::Resource.new("one::two", "/my/file").should respond_to(:to_manifest)
   end
 
   describe "when converting to puppet code" do
     before do
       @resource = Puppet::Resource.new("one::two", "/my/file", :parameters => {:noop => true, :foo => %w{one two}})
     end
 
     it "should print the type and title" do
       @resource.to_manifest.should be_include("one::two { '/my/file':\n")
     end
 
     it "should print each parameter, with the value single-quoted" do
       @resource.to_manifest.should be_include("    noop => 'true'")
     end
 
     it "should print array values appropriately" do
       @resource.to_manifest.should be_include("    foo => ['one','two']")
     end
   end
 
   it "should be able to convert itself to a TransObject instance" do
     Puppet::Resource.new("one::two", "/my/file").should respond_to(:to_trans)
   end
 
   describe "when converting to a TransObject" do
     describe "and the resource is not an instance of a builtin type" do
       before do
         @resource = Puppet::Resource.new("foo", "bar")
       end
 
       it "should return a simple TransBucket if it is not an instance of a builtin type" do
         bucket = @resource.to_trans
         bucket.should be_instance_of(Puppet::TransBucket)
         bucket.type.should == @resource.type
         bucket.name.should == @resource.title
       end
 
       it "should return a simple TransBucket if it is a stage" do
         @resource = Puppet::Resource.new("stage", "bar")
         bucket = @resource.to_trans
         bucket.should be_instance_of(Puppet::TransBucket)
         bucket.type.should == @resource.type
         bucket.name.should == @resource.title
       end
 
       it "should copy over the resource's file" do
         @resource.file = "/foo/bar"
         @resource.to_trans.file.should == "/foo/bar"
       end
 
       it "should copy over the resource's line" do
         @resource.line = 50
         @resource.to_trans.line.should == 50
       end
     end
 
     describe "and the resource is an instance of a builtin type" do
       before do
         @resource = Puppet::Resource.new("file", "bar")
       end
 
       it "should return a TransObject if it is an instance of a builtin resource type" do
         trans = @resource.to_trans
         trans.should be_instance_of(Puppet::TransObject)
         trans.type.should == "file"
         trans.name.should == @resource.title
       end
 
       it "should copy over the resource's file" do
         @resource.file = "/foo/bar"
         @resource.to_trans.file.should == "/foo/bar"
       end
 
       it "should copy over the resource's line" do
         @resource.line = 50
         @resource.to_trans.line.should == 50
       end
 
       # Only TransObjects support tags, annoyingly
       it "should copy over the resource's tags" do
         @resource.tag "foo"
         @resource.to_trans.tags.should == @resource.tags
       end
 
       it "should copy the resource's parameters into the transobject and convert the parameter name to a string" do
         @resource[:foo] = "bar"
         @resource.to_trans["foo"].should == "bar"
       end
 
       it "should be able to copy arrays of values" do
         @resource[:foo] = %w{yay fee}
         @resource.to_trans["foo"].should == %w{yay fee}
       end
 
       it "should reduce single-value arrays to just a value" do
         @resource[:foo] = %w{yay}
         @resource.to_trans["foo"].should == "yay"
       end
 
       it "should convert resource references into the backward-compatible form" do
         @resource[:foo] = Puppet::Resource.new(:file, "/f")
         @resource.to_trans["foo"].should == %w{File /f}
       end
 
       it "should convert resource references into the backward-compatible form even when within arrays" do
         @resource[:foo] = ["a", Puppet::Resource.new(:file, "/f")]
         @resource.to_trans["foo"].should == ["a", %w{File /f}]
       end
     end
   end
 
-  describe "when converting to pson" do
-    confine "Missing 'pson' library" => Puppet.features.pson?
-
+  describe "when converting to pson", :if => Puppet.features.pson? do
     def pson_output_should
       @resource.class.expects(:pson_create).with { |hash| yield hash }
     end
 
     it "should include the pson util module" do
       Puppet::Resource.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
     end
 
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
 
     it "should set its type to the provided type" do
       Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type.should == "File"
     end
 
     it "should set its title to the provided title" do
       Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title.should == "/foo"
     end
 
     it "should include all tags from the resource" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.tag("yay")
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).tags.should == resource.tags
     end
 
     it "should include the file if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.file = "/my/file"
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).file.should == "/my/file"
     end
 
     it "should include the line if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.line = 50
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).line.should == 50
     end
 
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_true
     end
 
     it "should set 'exported' to false if no value is set" do
       resource = Puppet::Resource.new("File", "/foo")
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_false
     end
 
     it "should set all of its parameters as the 'parameters' entry" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:foo] = %w{bar eh}
       resource[:fee] = %w{baz}
 
       result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
       result["foo"].should == %w{bar eh}
       result["fee"].should == %w{baz}
     end
 
     it "should serialize relationships as reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = Puppet::Resource.new("File", "/bar")
       result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
       result[:requires].should == "File[/bar]"
     end
 
     it "should serialize multiple relationships as arrays of reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = [Puppet::Resource.new("File", "/bar"), Puppet::Resource.new("File", "/baz")]
       result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
       result[:requires].should == [ "File[/bar]",  "File[/baz]" ]
     end
   end
 
-  describe "when converting from pson" do
-    confine "Missing 'pson' library" => Puppet.features.pson?
-
+  describe "when converting from pson", :if => Puppet.features.pson? do
     def pson_result_should
       Puppet::Resource.expects(:new).with { |hash| yield hash }
     end
 
     before do
       @data = {
         'type' => "file",
         'title' => @basepath+"/yay",
       }
     end
 
     it "should set its type to the provided type" do
       Puppet::Resource.from_pson(@data).type.should == "File"
     end
 
     it "should set its title to the provided title" do
       Puppet::Resource.from_pson(@data).title.should == @basepath+"/yay"
     end
 
     it "should tag the resource with any provided tags" do
       @data['tags'] = %w{foo bar}
       resource = Puppet::Resource.from_pson(@data)
       resource.tags.should be_include("foo")
       resource.tags.should be_include("bar")
     end
 
     it "should set its file to the provided file" do
       @data['file'] = "/foo/bar"
       Puppet::Resource.from_pson(@data).file.should == "/foo/bar"
     end
 
     it "should set its line to the provided line" do
       @data['line'] = 50
       Puppet::Resource.from_pson(@data).line.should == 50
     end
 
     it "should 'exported' to true if set in the pson data" do
       @data['exported'] = true
       Puppet::Resource.from_pson(@data).exported.should be_true
     end
 
     it "should 'exported' to false if not set in the pson data" do
       Puppet::Resource.from_pson(@data).exported.should be_false
     end
 
     it "should fail if no title is provided" do
       @data.delete('title')
       lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
     end
 
     it "should fail if no type is provided" do
       @data.delete('type')
       lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
     end
 
     it "should set each of the provided parameters" do
       @data['parameters'] = {'foo' => %w{one two}, 'fee' => %w{three four}}
       resource = Puppet::Resource.from_pson(@data)
       resource['foo'].should == %w{one two}
       resource['fee'].should == %w{three four}
     end
 
     it "should convert single-value array parameters to normal values" do
       @data['parameters'] = {'foo' => %w{one}}
       resource = Puppet::Resource.from_pson(@data)
       resource['foo'].should == %w{one}
     end
   end
 
   describe "it should implement to_resource" do
     resource = Puppet::Resource.new("file", "/my/file")
     resource.to_resource.should == resource
   end
 
   describe "because it is an indirector model" do
     it "should include Puppet::Indirector" do
       Puppet::Resource.should be_is_a(Puppet::Indirector)
     end
 
     it "should have a default terminus" do
       Puppet::Resource.indirection.terminus_class.should == :ral
     end
 
     it "should have a name" do
       Puppet::Resource.new("file", "/my/file").name.should == "File//my/file"
     end
   end
 
   describe "when resolving resources with a catalog" do
     it "should resolve all resources using the catalog" do
       catalog = mock 'catalog'
       resource = Puppet::Resource.new("foo::bar", "yay")
       resource.catalog = catalog
 
       catalog.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
 
       resource.resolve.should == :myresource
     end
   end
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
       Puppet::Type.type(:file).stubs(:key_attributes).returns [:myvar, :owner, :path]
       Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})
       res.uniqueness_key.should == [ nil, 'root', '/my/file']
     end
   end
 end
diff --git a/spec/unit/ssl/certificate_authority/interface_spec.rb b/spec/unit/ssl/certificate_authority/interface_spec.rb
index d8c351ae2..5cf4073df 100755
--- a/spec/unit/ssl/certificate_authority/interface_spec.rb
+++ b/spec/unit/ssl/certificate_authority/interface_spec.rb
@@ -1,333 +1,333 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/ssl/certificate_authority'
 
-describe "a normal interface method", :shared => true do
+shared_examples_for "a normal interface method" do
   it "should call the method on the CA for each host specified if an array was provided" do
     @ca.expects(@method).with("host1")
     @ca.expects(@method).with("host2")
 
     @applier = Puppet::SSL::CertificateAuthority::Interface.new(@method, :to => %w{host1 host2})
 
     @applier.apply(@ca)
   end
 
   it "should call the method on the CA for all existing certificates if :all was provided" do
     @ca.expects(:list).returns %w{host1 host2}
 
     @ca.expects(@method).with("host1")
     @ca.expects(@method).with("host2")
 
     @applier = Puppet::SSL::CertificateAuthority::Interface.new(@method, :to => :all)
 
     @applier.apply(@ca)
   end
 end
 
 describe Puppet::SSL::CertificateAuthority::Interface do
   before do
     @class = Puppet::SSL::CertificateAuthority::Interface
   end
   describe "when initializing" do
     it "should set its method using its settor" do
       @class.any_instance.expects(:method=).with(:generate)
       @class.new(:generate, :to => :all)
     end
 
     it "should set its subjects using the settor" do
       @class.any_instance.expects(:subjects=).with(:all)
       @class.new(:generate, :to => :all)
     end
 
     it "should set the digest if given" do
       interface = @class.new(:generate, :to => :all, :digest => :digest)
       interface.digest.should == :digest
     end
 
     it "should set the digest to md5 if none given" do
       interface = @class.new(:generate, :to => :all)
       interface.digest.should == :MD5
     end
   end
 
   describe "when setting the method" do
     it "should set the method" do
       @class.new(:generate, :to => :all).method.should == :generate
     end
 
     it "should fail if the method isn't a member of the INTERFACE_METHODS array" do
       Puppet::SSL::CertificateAuthority::Interface::INTERFACE_METHODS.expects(:include?).with(:thing).returns false
 
       lambda { @class.new(:thing, :to => :all) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when setting the subjects" do
     it "should set the subjects" do
       @class.new(:generate, :to => :all).subjects.should == :all
     end
 
     it "should fail if the subjects setting isn't :all or an array" do
       lambda { @class.new(:generate, "other") }.should raise_error(ArgumentError)
     end
   end
 
   it "should have a method for triggering the application" do
     @class.new(:generate, :to => :all).should respond_to(:apply)
   end
 
   describe "when applying" do
     before do
       # We use a real object here, because :verify can't be stubbed, apparently.
       @ca = Object.new
     end
 
     it "should raise InterfaceErrors" do
       @applier = @class.new(:revoke, :to => :all)
 
       @ca.expects(:list).raises Puppet::SSL::CertificateAuthority::Interface::InterfaceError
 
       lambda { @applier.apply(@ca) }.should raise_error(Puppet::SSL::CertificateAuthority::Interface::InterfaceError)
     end
 
     it "should log non-Interface failures rather than failing" do
       @applier = @class.new(:revoke, :to => :all)
 
       @ca.expects(:list).raises ArgumentError
 
       Puppet.expects(:err)
 
       lambda { @applier.apply(@ca) }.should_not raise_error
     end
 
     describe "with an empty array specified and the method is not list" do
       it "should fail" do
         @applier = @class.new(:sign, :to => [])
         lambda { @applier.apply(@ca) }.should raise_error(ArgumentError)
       end
     end
 
     describe ":generate" do
       it "should fail if :all was specified" do
         @applier = @class.new(:generate, :to => :all)
         lambda { @applier.apply(@ca) }.should raise_error(ArgumentError)
       end
 
       it "should call :generate on the CA for each host specified" do
         @applier = @class.new(:generate, :to => %w{host1 host2})
 
         @ca.expects(:generate).with("host1")
         @ca.expects(:generate).with("host2")
 
         @applier.apply(@ca)
       end
     end
 
     describe ":verify" do
       before { @method = :verify }
       #it_should_behave_like "a normal interface method"
 
       it "should call the method on the CA for each host specified if an array was provided" do
         # LAK:NOTE Mocha apparently doesn't allow you to mock :verify, but I'm confident this works in real life.
       end
 
       it "should call the method on the CA for all existing certificates if :all was provided" do
         # LAK:NOTE Mocha apparently doesn't allow you to mock :verify, but I'm confident this works in real life.
       end
     end
 
     describe ":destroy" do
       before { @method = :destroy }
       it_should_behave_like "a normal interface method"
     end
 
     describe ":revoke" do
       before { @method = :revoke }
       it_should_behave_like "a normal interface method"
     end
 
     describe ":sign" do
       describe "and an array of names was provided" do
         before do
           @applier = @class.new(:sign, :to => %w{host1 host2})
         end
 
         it "should sign the specified waiting certificate requests" do
           @ca.expects(:sign).with("host1")
           @ca.expects(:sign).with("host2")
 
           @applier.apply(@ca)
         end
       end
 
       describe "and :all was provided" do
         it "should sign all waiting certificate requests" do
           @ca.stubs(:waiting?).returns(%w{cert1 cert2})
 
           @ca.expects(:sign).with("cert1")
           @ca.expects(:sign).with("cert2")
 
           @applier = @class.new(:sign, :to => :all)
           @applier.apply(@ca)
         end
 
         it "should fail if there are no waiting certificate requests" do
           @ca.stubs(:waiting?).returns([])
 
           @applier = @class.new(:sign, :to => :all)
           lambda { @applier.apply(@ca) }.should raise_error(Puppet::SSL::CertificateAuthority::Interface::InterfaceError)
         end
       end
     end
 
     describe ":list" do
       describe "and an empty array was provided" do
         it "should print a string containing all certificate requests" do
           @ca.expects(:waiting?).returns %w{host1 host2}
           @ca.stubs(:verify)
 
           @applier = @class.new(:list, :to => [])
 
           @applier.expects(:puts).with "host1\nhost2"
 
           @applier.apply(@ca)
         end
       end
 
       describe "and :all was provided" do
         it "should print a string containing all certificate requests and certificates" do
           @ca.expects(:waiting?).returns %w{host1 host2}
           @ca.expects(:list).returns %w{host3 host4}
           @ca.stubs(:verify)
           @ca.stubs(:fingerprint).returns "fingerprint"
           @ca.expects(:verify).with("host3").raises(Puppet::SSL::CertificateAuthority::CertificateVerificationError.new(23), "certificate revoked")
 
           @applier = @class.new(:list, :to => :all)
 
           @applier.expects(:puts).with "host1 (fingerprint)"
           @applier.expects(:puts).with "host2 (fingerprint)"
           @applier.expects(:puts).with "- host3 (fingerprint) (certificate revoked)"
           @applier.expects(:puts).with "+ host4 (fingerprint)"
 
           @applier.apply(@ca)
         end
       end
 
       describe "and :signed was provided" do
         it "should print a string containing all signed certificate requests and certificates" do
           @ca.expects(:list).returns %w{host1 host2}
 
           @applier = @class.new(:list, :to => :signed)
 
           @applier.apply(@ca)
         end
       end
 
       describe "and an array of names was provided" do
         it "should print a string of all named hosts that have a waiting request" do
           @ca.expects(:waiting?).returns %w{host1 host2}
           @ca.expects(:list).returns %w{host3 host4}
           @ca.stubs(:fingerprint).returns "fingerprint"
           @ca.stubs(:verify)
 
           @applier = @class.new(:list, :to => %w{host1 host2 host3 host4})
 
           @applier.expects(:puts).with "host1 (fingerprint)"
           @applier.expects(:puts).with "host2 (fingerprint)"
           @applier.expects(:puts).with "+ host3 (fingerprint)"
           @applier.expects(:puts).with "+ host4 (fingerprint)"
 
           @applier.apply(@ca)
         end
       end
     end
 
     describe ":print" do
       describe "and :all was provided" do
         it "should print all certificates" do
           @ca.expects(:list).returns %w{host1 host2}
 
           @applier = @class.new(:print, :to => :all)
 
           @ca.expects(:print).with("host1").returns "h1"
           @applier.expects(:puts).with "h1"
 
           @ca.expects(:print).with("host2").returns "h2"
           @applier.expects(:puts).with "h2"
 
           @applier.apply(@ca)
         end
       end
 
       describe "and an array of names was provided" do
         it "should print each named certificate if found" do
           @applier = @class.new(:print, :to => %w{host1 host2})
 
           @ca.expects(:print).with("host1").returns "h1"
           @applier.expects(:puts).with "h1"
 
           @ca.expects(:print).with("host2").returns "h2"
           @applier.expects(:puts).with "h2"
 
           @applier.apply(@ca)
         end
 
         it "should log any named but not found certificates" do
           @applier = @class.new(:print, :to => %w{host1 host2})
 
           @ca.expects(:print).with("host1").returns "h1"
           @applier.expects(:puts).with "h1"
 
           @ca.expects(:print).with("host2").returns nil
           Puppet.expects(:err).with { |msg| msg.include?("host2") }
 
           @applier.apply(@ca)
         end
       end
     end
 
     describe ":fingerprint" do
       it "should fingerprint with the set digest algorithm" do
         @applier = @class.new(:fingerprint, :to => %w{host1}, :digest => :digest)
 
         @ca.expects(:fingerprint).with("host1", :digest).returns "fingerprint1"
         @applier.expects(:puts).with "host1 fingerprint1"
 
         @applier.apply(@ca)
       end
 
       describe "and :all was provided" do
         it "should fingerprint all certificates (including waiting ones)" do
           @ca.expects(:list).returns %w{host1}
           @ca.expects(:waiting?).returns %w{host2}
 
           @applier = @class.new(:fingerprint, :to => :all)
 
           @ca.expects(:fingerprint).with("host1", :MD5).returns "fingerprint1"
           @applier.expects(:puts).with "host1 fingerprint1"
 
           @ca.expects(:fingerprint).with("host2", :MD5).returns "fingerprint2"
           @applier.expects(:puts).with "host2 fingerprint2"
 
           @applier.apply(@ca)
         end
       end
 
       describe "and an array of names was provided" do
         it "should print each named certificate if found" do
           @applier = @class.new(:fingerprint, :to => %w{host1 host2})
 
           @ca.expects(:fingerprint).with("host1", :MD5).returns "fingerprint1"
           @applier.expects(:puts).with "host1 fingerprint1"
 
           @ca.expects(:fingerprint).with("host2", :MD5).returns "fingerprint2"
           @applier.expects(:puts).with "host2 fingerprint2"
 
           @applier.apply(@ca)
         end
       end
     end
   end
 end
diff --git a/spec/unit/type/augeas_spec.rb b/spec/unit/type/augeas_spec.rb
index e426fbeed..d2e40f0f6 100644
--- a/spec/unit/type/augeas_spec.rb
+++ b/spec/unit/type/augeas_spec.rb
@@ -1,122 +1,120 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 augeas = Puppet::Type.type(:augeas)
 
 describe augeas do
-  describe "when augeas is present" do
-    confine "Augeas is unavailable" => Puppet.features.augeas?
-
+  describe "when augeas is present", :if => Puppet.features.augeas? do
     it "should have a default provider inheriting from Puppet::Provider" do
       augeas.defaultprovider.ancestors.should be_include(Puppet::Provider)
     end
 
     it "should have a valid provider" do
       augeas.new(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
     end
   end
 
   describe "basic structure" do
     it "should be able to create a instance" do
       provider_class = Puppet::Type::Augeas.provider(Puppet::Type::Augeas.providers[0])
       Puppet::Type::Augeas.expects(:defaultprovider).returns provider_class
       augeas.new(:name => "bar").should_not be_nil
     end
 
     it "should have an parse_commands feature" do
       augeas.provider_feature(:parse_commands).should_not be_nil
     end
 
     it "should have an need_to_run? feature" do
       augeas.provider_feature(:need_to_run?).should_not be_nil
     end
 
     it "should have an execute_changes feature" do
       augeas.provider_feature(:execute_changes).should_not be_nil
     end
 
     properties = [:returns]
     params = [:name, :context, :onlyif, :changes, :root, :load_path, :type_check]
 
     properties.each do |property|
       it "should have a #{property} property" do
         augeas.attrclass(property).ancestors.should be_include(Puppet::Property)
       end
 
       it "should have documentation for its #{property} property" do
         augeas.attrclass(property).doc.should be_instance_of(String)
       end
     end
 
     params.each do |param|
       it "should have a #{param} parameter" do
         augeas.attrclass(param).ancestors.should be_include(Puppet::Parameter)
       end
 
       it "should have documentation for its #{param} parameter" do
         augeas.attrclass(param).doc.should be_instance_of(String)
       end
     end
   end
 
   describe "default values" do
     before do
       provider_class = augeas.provider(augeas.providers[0])
       augeas.expects(:defaultprovider).returns provider_class
     end
 
     it "should be blank for context" do
       augeas.new(:name => :context)[:context].should == ""
     end
 
     it "should be blank for onlyif" do
       augeas.new(:name => :onlyif)[:onlyif].should == ""
     end
 
     it "should be blank for load_path" do
       augeas.new(:name => :load_path)[:load_path].should == ""
     end
 
     it "should be / for root" do
       augeas.new(:name => :root)[:root].should == "/"
     end
 
     it "should be false for type_check" do
       augeas.new(:name => :type_check)[:type_check].should == :false
     end
   end
 
   describe "provider interaction" do
 
     it "should return 0 if it does not need to run" do
       provider = stub("provider", :need_to_run? => false)
       resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
       changes = augeas.attrclass(:returns).new(:resource => resource)
       changes.retrieve.should == 0
     end
 
     it "should return :need_to_run if it needs to run" do
       provider = stub("provider", :need_to_run? => true)
       resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
       changes = augeas.attrclass(:returns).new(:resource => resource)
       changes.retrieve.should == :need_to_run
     end
   end
 
   describe "loading specific files" do
     it "should require lens when incl is used" do
       lambda { augeas.new(:name => :no_lens, :incl => "/etc/hosts")}.should raise_error(Puppet::Error)
     end
 
     it "should require incl when lens is used" do
       lambda { augeas.new(:name => :no_incl, :lens => "Hosts.lns") }.should raise_error(Puppet::Error)
     end
 
     it "should set the context when a specific file is used" do
       fake_provider = stub_everything "fake_provider"
       augeas.stubs(:defaultprovider).returns fake_provider
       augeas.new(:name => :no_incl, :lens => "Hosts.lns", :incl => "/etc/hosts")[:context].should == "/files/etc/hosts"
     end
   end
 end
diff --git a/spec/unit/type/file_spec.rb b/spec/unit/type/file_spec.rb
index 4fcad07e1..22921d85a 100755
--- a/spec/unit/type/file_spec.rb
+++ b/spec/unit/type/file_spec.rb
@@ -1,1070 +1,1068 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:file) do
   before do
     Puppet.settings.stubs(:use)
     @real_posix = Puppet.features.posix?
     Puppet.features.stubs("posix?").returns(true)
 
     @path = Tempfile.new("puppetspec")
     pathname = @path.path
     @path.close!()
     @path = pathname
     @file = Puppet::Type::File.new(:name => @path)
 
     @catalog = Puppet::Resource::Catalog.new
     @file.catalog = @catalog
   end
 
   describe "when determining if recursion is enabled" do
     it "should default to recursion being disabled" do
       @file.should_not be_recurse
     end
     [true, "true", 10, "inf", "remote"].each do |value|
       it "should consider #{value} to enable recursion" do
         @file[:recurse] = value
         @file.must be_recurse
       end
     end
 
     [false, "false", 0].each do |value|
       it "should consider #{value} to disable recursion" do
         @file[:recurse] = value
         @file.should_not be_recurse
       end
     end
   end
 
   describe "#write" do
 
     it "should propagate failures encountered when renaming the temporary file" do
       File.stubs(:open)
 
       File.expects(:rename).raises ArgumentError
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
 
       file.stubs(:validate_checksum?).returns(false)
 
       property = stub('content_property', :actual_content => "something", :length => "something".length)
       file.stubs(:property).with(:content).returns(property)
 
       lambda { file.write(:content) }.should raise_error(Puppet::Error)
     end
 
     it "should delegate writing to the content property" do
       filehandle = stub_everything 'fh'
       File.stubs(:open).yields(filehandle)
       File.stubs(:rename)
       property = stub('content_property', :actual_content => "something", :length => "something".length)
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
       file.stubs(:validate_checksum?).returns(false)
       file.stubs(:property).with(:content).returns(property)
 
       property.expects(:write).with(filehandle)
 
       file.write(:content)
     end
 
     describe "when validating the checksum" do
       before { @file.stubs(:validate_checksum?).returns(true) }
 
       it "should fail if the checksum parameter and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b', :sum_file => 'checksum_b')
         @file.stubs(:parameter).with(:checksum).returns(checksum)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         @file.stubs(:property).with(:content).returns(property)
 
         lambda { @file.write :NOTUSED }.should raise_error(Puppet::Error)
       end
     end
 
     describe "when not validating the checksum" do
       before { @file.stubs(:validate_checksum?).returns(false) }
 
       it "should not fail if the checksum property and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b')
         @file.stubs(:parameter).with(:checksum).returns(checksum)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         @file.stubs(:property).with(:content).returns(property)
 
         lambda { @file.write :NOTUSED }.should_not raise_error(Puppet::Error)
       end
 
     end
   end
 
   it "should have a method for determining if the file is present" do
     @file.must respond_to(:exist?)
   end
 
   it "should be considered existent if it can be stat'ed" do
     @file.expects(:stat).returns mock('stat')
     @file.must be_exist
   end
 
   it "should be considered nonexistent if it can not be stat'ed" do
     @file.expects(:stat).returns nil
     @file.must_not be_exist
   end
 
   it "should have a method for determining if the file should be a normal file" do
     @file.must respond_to(:should_be_file?)
   end
 
   it "should be a file if :ensure is set to :file" do
     @file[:ensure] = :file
     @file.must be_should_be_file
   end
 
   it "should be a file if :ensure is set to :present and the file exists as a normal file" do
     @file.stubs(:stat).returns(mock('stat', :ftype => "file"))
     @file[:ensure] = :present
     @file.must be_should_be_file
   end
 
   it "should not be a file if :ensure is set to something other than :file" do
     @file[:ensure] = :directory
     @file.must_not be_should_be_file
   end
 
   it "should not be a file if :ensure is set to :present and the file exists but is not a normal file" do
     @file.stubs(:stat).returns(mock('stat', :ftype => "directory"))
     @file[:ensure] = :present
     @file.must_not be_should_be_file
   end
 
   it "should be a file if :ensure is not set and :content is" do
     @file[:content] = "foo"
     @file.must be_should_be_file
   end
 
   it "should be a file if neither :ensure nor :content is set but the file exists as a normal file" do
     @file.stubs(:stat).returns(mock("stat", :ftype => "file"))
     @file.must be_should_be_file
   end
 
   it "should not be a file if neither :ensure nor :content is set but the file exists but not as a normal file" do
     @file.stubs(:stat).returns(mock("stat", :ftype => "directory"))
     @file.must_not be_should_be_file
   end
 
   describe "when using POSIX filenames" do
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "/foo/bar")
         dir = Puppet::Type::File.new(:path => "/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "/")
         @catalog.add_resource file
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar/baz/")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar//baz")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar/baz//")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should leave a single slash alone" do
         file = Puppet::Type::File.new(:path => "/")
         file[:path].should == "/"
       end
     end
 
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
-  describe "when using Microsoft Windows filenames" do
-    confine "Only works on Microsoft Windows" => Puppet.features.microsoft_windows?
+  describe "when using Microsoft Windows filenames", :if => Puppet.features.microsoft_windows? do
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar")
         dir = Puppet::Type::File.new(:path => "X:/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "X:/")
         @catalog.add_resource file
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar/baz/")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar//baz")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar/baz//")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should leave a drive letter with a slash alone" do
         file = Puppet::Type::File.new(:path => "X:/")
         file[:path].should == "X:/"
       end
 
       it "should add a slash to a drive letter" do
         file = Puppet::Type::File.new(:path => "X:")
         file[:path].should == "X:/"
       end
     end
 
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "X:/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when using UNC filenames" do
-    describe "on Microsoft Windows systems" do
-      confine "Only works on Microsoft Windows" => Puppet.features.microsoft_windows?
+    describe "on Microsoft Windows systems", :if => Puppet.features.microsoft_windows? do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar")
         dir = Puppet::Type::File.new(:path => "//server/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "//server/foo")
         @catalog.add_resource file
         puts file.autorequire
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar/baz/")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar//baz")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar/baz//")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove a trailing slash from a sharename" do
         file = Puppet::Type::File.new(:path => "//server/foo/")
         file[:path].should == "//server/foo"
       end
 
       it "should not modify a sharename" do
         file = Puppet::Type::File.new(:path => "//server/foo")
         file[:path].should == "//server/foo"
       end
     end
 
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "X:/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when initializing" do
     it "should set a desired 'ensure' value if none is set and 'content' is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :content => "/foo/bar")
       file[:ensure].should == :file
     end
 
     it "should set a desired 'ensure' value if none is set and 'target' is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :target => "/foo/bar")
       file[:ensure].should == :symlink
     end
   end
 
   describe "when validating attributes" do
     %w{path checksum backup recurse recurselimit source replace force ignore links purge sourceselect}.each do |attr|
       it "should have a '#{attr}' parameter" do
         Puppet::Type.type(:file).attrtype(attr.intern).should == :param
       end
     end
 
     %w{content target ensure owner group mode type}.each do |attr|
       it "should have a '#{attr}' property" do
         Puppet::Type.type(:file).attrtype(attr.intern).should == :property
       end
     end
 
     it "should have its 'path' attribute set as its namevar" do
       Puppet::Type.type(:file).key_attributes.should == [:path]
     end
   end
 
   describe "when managing links" do
     require 'puppettest/support/assertions'
     include PuppetTest
     require 'tempfile'
 
     if @real_posix
       describe "on POSIX systems" do
         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.type(:file).new(
-                
+
             :path => @link,
-        
+
             :mode => "755"
           )
           @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
     else # @real_posix
       # should recode tests using expectations instead of using the filesystem
     end
 
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should refuse to work with links"
     end
   end
 
   it "should be able to retrieve a stat instance for the file it is managing" do
     Puppet::Type.type(:file).new(:path => "/foo/bar", :source => "/bar/foo").should respond_to(:stat)
   end
 
   describe "when stat'ing its file" do
     before do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar")
       @resource[:links] = :manage # so we always use :lstat
     end
 
     it "should use :stat if it is following links" do
       @resource[:links] = :follow
       File.expects(:stat)
 
       @resource.stat
     end
 
     it "should use :lstat if is it not following links" do
       @resource[:links] = :manage
       File.expects(:lstat)
 
       @resource.stat
     end
 
     it "should stat the path of the file" do
       File.expects(:lstat).with("/foo/bar")
 
       @resource.stat
     end
 
     # This only happens in testing.
     it "should return nil if the stat does not exist" do
       File.expects(:lstat).returns nil
 
       @resource.stat.should be_nil
     end
 
     it "should return nil if the file does not exist" do
       File.expects(:lstat).raises(Errno::ENOENT)
 
       @resource.stat.should be_nil
     end
 
     it "should return nil if the file cannot be stat'ed" do
       File.expects(:lstat).raises(Errno::EACCES)
 
       @resource.stat.should be_nil
     end
 
     it "should return the stat instance" do
       File.expects(:lstat).returns "mystat"
 
       @resource.stat.should == "mystat"
     end
 
     it "should cache the stat instance if it has a catalog and is applying" do
       stat = mock 'stat'
       File.expects(:lstat).returns stat
 
       catalog = Puppet::Resource::Catalog.new
       @resource.catalog = catalog
 
       catalog.stubs(:applying?).returns true
 
       @resource.stat.should equal(@resource.stat)
     end
   end
 
   describe "when flushing" do
     it "should flush all properties that respond to :flush" do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar", :source => "/bar/foo")
       @resource.parameter(:source).expects(:flush)
       @resource.flush
     end
 
     it "should reset its stat reference" do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar")
       File.expects(:lstat).times(2).returns("stat1").then.returns("stat2")
       @resource.stat.should == "stat1"
       @resource.flush
       @resource.stat.should == "stat2"
     end
   end
 
   it "should have a method for performing recursion" do
     @file.must respond_to(:perform_recursion)
   end
 
   describe "when executing a recursive search" do
     it "should use Metadata to do its recursion" do
       Puppet::FileServing::Metadata.expects(:search)
       @file.perform_recursion(@file[:path])
     end
 
     it "should use the provided path as the key to the search" do
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| key == "/foo" }
       @file.perform_recursion("/foo")
     end
 
     it "should return the results of the metadata search" do
       Puppet::FileServing::Metadata.expects(:search).returns "foobar"
       @file.perform_recursion(@file[:path]).should == "foobar"
     end
 
     it "should pass its recursion value to the search" do
       @file[:recurse] = true
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurse] == true }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass true if recursion is remote" do
       @file[:recurse] = :remote
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurse] == true }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass its recursion limit value to the search" do
       @file[:recurselimit] = 10
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurselimit] == 10 }
       @file.perform_recursion(@file[:path])
     end
 
     it "should configure the search to ignore or manage links" do
       @file[:links] = :manage
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:links] == :manage }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass its 'ignore' setting to the search if it has one" do
       @file[:ignore] = %w{.svn CVS}
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:ignore] == %w{.svn CVS} }
       @file.perform_recursion(@file[:path])
     end
   end
 
   it "should have a method for performing local recursion" do
     @file.must respond_to(:recurse_local)
   end
 
   describe "when doing local recursion" do
     before do
       @metadata = stub 'metadata', :relative_path => "my/file"
     end
 
     it "should pass its path to the :perform_recursion method" do
       @file.expects(:perform_recursion).with(@file[:path]).returns [@metadata]
       @file.stubs(:newchild)
       @file.recurse_local
     end
 
     it "should return an empty hash if the recursion returns nothing" do
       @file.expects(:perform_recursion).returns nil
       @file.recurse_local.should == {}
     end
 
     it "should create a new child resource with each generated metadata instance's relative path" do
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).with(@metadata.relative_path).returns "fiebar"
       @file.recurse_local
     end
 
     it "should not create a new child resource for the '.' directory" do
       @metadata.stubs(:relative_path).returns "."
 
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).never
       @file.recurse_local
     end
 
     it "should return a hash of the created resources with the relative paths as the hash keys" do
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).with("my/file").returns "fiebar"
       @file.recurse_local.should == {"my/file" => "fiebar"}
     end
 
     it "should set checksum_type to none if this file checksum is none" do
       @file[:checksum] = :none
       Puppet::FileServing::Metadata.expects(:search).with { |path,params| params[:checksum_type] == :none }.returns [@metadata]
       @file.expects(:newchild).with("my/file").returns "fiebar"
       @file.recurse_local
     end
   end
 
   it "should have a method for performing link recursion" do
     @file.must respond_to(:recurse_link)
   end
 
   describe "when doing link recursion" do
     before do
       @first = stub 'first', :relative_path => "first", :full_path => "/my/first", :ftype => "directory"
       @second = stub 'second', :relative_path => "second", :full_path => "/my/second", :ftype => "file"
 
       @resource = stub 'file', :[]= => nil
     end
 
     it "should pass its target to the :perform_recursion method" do
       @file[:target] = "mylinks"
       @file.expects(:perform_recursion).with("mylinks").returns [@first]
       @file.stubs(:newchild).returns @resource
       @file.recurse_link({})
     end
 
     it "should ignore the recursively-found '.' file and configure the top-level file to create a directory" do
       @first.stubs(:relative_path).returns "."
       @file[:target] = "mylinks"
       @file.expects(:perform_recursion).with("mylinks").returns [@first]
       @file.stubs(:newchild).never
       @file.expects(:[]=).with(:ensure, :directory)
       @file.recurse_link({})
     end
 
     it "should create a new child resource for each generated metadata instance's relative path that doesn't already exist in the children hash" do
       @file.expects(:perform_recursion).returns [@first, @second]
       @file.expects(:newchild).with(@first.relative_path).returns @resource
       @file.recurse_link("second" => @resource)
     end
 
     it "should not create a new child resource for paths that already exist in the children hash" do
       @file.expects(:perform_recursion).returns [@first]
       @file.expects(:newchild).never
       @file.recurse_link("first" => @resource)
     end
 
     it "should set the target to the full path of discovered file and set :ensure to :link if the file is not a directory" do
       file = stub 'file'
       file.expects(:[]=).with(:target, "/my/second")
       file.expects(:[]=).with(:ensure, :link)
 
       @file.stubs(:perform_recursion).returns [@first, @second]
       @file.recurse_link("first" => @resource, "second" => file)
     end
 
     it "should :ensure to :directory if the file is a directory" do
       file = stub 'file'
       file.expects(:[]=).with(:ensure, :directory)
 
       @file.stubs(:perform_recursion).returns [@first, @second]
       @file.recurse_link("first" => file, "second" => @resource)
     end
 
     it "should return a hash with both created and existing resources with the relative paths as the hash keys" do
       file = stub 'file', :[]= => nil
 
       @file.expects(:perform_recursion).returns [@first, @second]
       @file.stubs(:newchild).returns file
       @file.recurse_link("second" => @resource).should == {"second" => @resource, "first" => file}
     end
   end
 
   it "should have a method for performing remote recursion" do
     @file.must respond_to(:recurse_remote)
   end
 
   describe "when doing remote recursion" do
     before do
       @file[:source] = "puppet://foo/bar"
 
       @first = Puppet::FileServing::Metadata.new("/my", :relative_path => "first")
       @second = Puppet::FileServing::Metadata.new("/my", :relative_path => "second")
       @first.stubs(:ftype).returns "directory"
       @second.stubs(:ftype).returns "directory"
 
       @parameter = stub 'property', :metadata= => nil
       @resource = stub 'file', :[]= => nil, :parameter => @parameter
     end
 
     it "should pass its source to the :perform_recursion method" do
       data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
       @file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       @file.stubs(:newchild).returns @resource
       @file.recurse_remote({})
     end
 
     it "should not recurse when the remote file is not a directory" do
       data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => ".")
       data.stubs(:ftype).returns "file"
       @file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       @file.expects(:newchild).never
       @file.recurse_remote({})
     end
 
     it "should set the source of each returned file to the searched-for URI plus the found relative path" do
       @first.expects(:source=).with File.join("puppet://foo/bar", @first.relative_path)
       @file.expects(:perform_recursion).returns [@first]
       @file.stubs(:newchild).returns @resource
       @file.recurse_remote({})
     end
 
     it "should create a new resource for any relative file paths that do not already have a resource" do
       @file.stubs(:perform_recursion).returns [@first]
       @file.expects(:newchild).with("first").returns @resource
       @file.recurse_remote({}).should == {"first" => @resource}
     end
 
     it "should not create a new resource for any relative file paths that do already have a resource" do
       @file.stubs(:perform_recursion).returns [@first]
       @file.expects(:newchild).never
       @file.recurse_remote("first" => @resource)
     end
 
     it "should set the source of each resource to the source of the metadata" do
       @file.stubs(:perform_recursion).returns [@first]
       @resource.stubs(:[]=)
       @resource.expects(:[]=).with(:source, File.join("puppet://foo/bar", @first.relative_path))
       @file.recurse_remote("first" => @resource)
     end
 
     # LAK:FIXME This is a bug, but I can't think of a fix for it.  Fortunately it's already
     # filed, and when it's fixed, we'll just fix the whole flow.
     it "should set the checksum type to :md5 if the remote file is a file" do
       @first.stubs(:ftype).returns "file"
       @file.stubs(:perform_recursion).returns [@first]
       @resource.stubs(:[]=)
       @resource.expects(:[]=).with(:checksum, :md5)
       @file.recurse_remote("first" => @resource)
     end
 
     it "should store the metadata in the source property for each resource so the source does not have to requery the metadata" do
       @file.stubs(:perform_recursion).returns [@first]
       @resource.expects(:parameter).with(:source).returns @parameter
 
       @parameter.expects(:metadata=).with(@first)
 
       @file.recurse_remote("first" => @resource)
     end
 
     it "should not create a new resource for the '.' file" do
       @first.stubs(:relative_path).returns "."
       @file.stubs(:perform_recursion).returns [@first]
 
       @file.expects(:newchild).never
 
       @file.recurse_remote({})
     end
 
     it "should store the metadata in the main file's source property if the relative path is '.'" do
       @first.stubs(:relative_path).returns "."
       @file.stubs(:perform_recursion).returns [@first]
 
       @file.parameter(:source).expects(:metadata=).with @first
 
       @file.recurse_remote("first" => @resource)
     end
 
     describe "and multiple sources are provided" do
       describe "and :sourceselect is set to :first" do
         it "should create file instances for the results for the first source to return any values" do
           data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
           @file[:source] = %w{/one /two /three /four}
           @file.expects(:perform_recursion).with("/one").returns nil
           @file.expects(:perform_recursion).with("/two").returns []
           @file.expects(:perform_recursion).with("/three").returns [data]
           @file.expects(:perform_recursion).with("/four").never
           @file.expects(:newchild).with("foobar").returns @resource
           @file.recurse_remote({})
         end
       end
 
       describe "and :sourceselect is set to :all" do
         before do
           @file[:sourceselect] = :all
         end
 
         it "should return every found file that is not in a previous source" do
           klass = Puppet::FileServing::Metadata
           @file[:source] = %w{/one /two /three /four}
           @file.stubs(:newchild).returns @resource
 
           one = [klass.new("/one", :relative_path => "a")]
           @file.expects(:perform_recursion).with("/one").returns one
           @file.expects(:newchild).with("a").returns @resource
 
           two = [klass.new("/two", :relative_path => "a"), klass.new("/two", :relative_path => "b")]
           @file.expects(:perform_recursion).with("/two").returns two
           @file.expects(:newchild).with("b").returns @resource
 
           three = [klass.new("/three", :relative_path => "a"), klass.new("/three", :relative_path => "c")]
           @file.expects(:perform_recursion).with("/three").returns three
           @file.expects(:newchild).with("c").returns @resource
 
           @file.expects(:perform_recursion).with("/four").returns []
 
           @file.recurse_remote({})
         end
       end
     end
   end
 
   describe "when returning resources with :eval_generate" do
     before do
       @graph = stub 'graph', :add_edge => nil
       @catalog.stubs(:relationship_graph).returns @graph
 
       @file.catalog = @catalog
       @file[:recurse] = true
     end
 
     it "should recurse if recursion is enabled" do
       resource = stub('resource', :[] => "resource")
       @file.expects(:recurse?).returns true
       @file.expects(:recurse).returns [resource]
       @file.eval_generate.should == [resource]
     end
 
     it "should not recurse if recursion is disabled" do
       @file.expects(:recurse?).returns false
       @file.expects(:recurse).never
       @file.eval_generate.should == []
     end
 
     it "should return each resource found through recursion" do
       foo = stub 'foo', :[] => "/foo"
       bar = stub 'bar', :[] => "/bar"
       bar2 = stub 'bar2', :[] => "/bar"
 
       @file.expects(:recurse).returns [foo, bar]
 
       @file.eval_generate.should == [foo, bar]
     end
   end
 
   describe "when recursing" do
     before do
       @file[:recurse] = true
       @metadata = Puppet::FileServing::Metadata
     end
 
     describe "and a source is set" do
       before { @file[:source] = "/my/source" }
 
       it "should pass the already-discovered resources to recurse_remote" do
         @file.stubs(:recurse_local).returns(:foo => "bar")
         @file.expects(:recurse_remote).with(:foo => "bar").returns []
         @file.recurse
       end
     end
 
     describe "and a target is set" do
       before { @file[:target] = "/link/target" }
 
       it "should use recurse_link" do
         @file.stubs(:recurse_local).returns(:foo => "bar")
         @file.expects(:recurse_link).with(:foo => "bar").returns []
         @file.recurse
       end
     end
 
     it "should use recurse_local if recurse is not remote" do
       @file.expects(:recurse_local).returns({})
       @file.recurse
     end
 
     it "should not use recurse_local if recurse remote" do
       @file[:recurse] = :remote
       @file.expects(:recurse_local).never
       @file.recurse
     end
 
     it "should return the generated resources as an array sorted by file path" do
       one = stub 'one', :[] => "/one"
       two = stub 'two', :[] => "/one/two"
       three = stub 'three', :[] => "/three"
       @file.expects(:recurse_local).returns(:one => one, :two => two, :three => three)
       @file.recurse.should == [one, two, three]
     end
 
     describe "and purging is enabled" do
       before do
         @file[:purge] = true
       end
 
       it "should configure each file to be removed" do
         local = stub 'local'
         local.stubs(:[]).with(:source).returns nil # Thus, a local file
         local.stubs(:[]).with(:path).returns "foo"
         @file.expects(:recurse_local).returns("local" => local)
         local.expects(:[]=).with(:ensure, :absent)
 
         @file.recurse
       end
 
       it "should not remove files that exist in the remote repository" do
         @file["source"] = "/my/file"
         @file.expects(:recurse_local).returns({})
 
         remote = stub 'remote'
         remote.stubs(:[]).with(:source).returns "/whatever" # Thus, a remote file
         remote.stubs(:[]).with(:path).returns "foo"
 
         @file.expects(:recurse_remote).with { |hash| hash["remote"] = remote }
         remote.expects(:[]=).with(:ensure, :absent).never
 
         @file.recurse
       end
     end
 
     describe "and making a new child resource" do
       it "should not copy the parent resource's parent" do
         Puppet::Type.type(:file).expects(:new).with { |options| ! options.include?(:parent) }
         @file.newchild("my/path")
       end
 
       {:recurse => true, :target => "/foo/bar", :ensure => :present, :alias => "yay", :source => "/foo/bar"}.each do |param, value|
         it "should not pass on #{param} to the sub resource" do
           @file = Puppet::Type::File.new(:name => @path, param => value, :catalog => @catalog)
 
           @file.class.expects(:new).with { |params| params[param].nil? }
 
           @file.newchild("sub/file")
         end
       end
 
       it "should copy all of the parent resource's 'should' values that were set at initialization" do
         file = @file.class.new(:path => "/foo/bar", :owner => "root", :group => "wheel")
         @catalog.add_resource(file)
         file.class.expects(:new).with { |options| options[:owner] == "root" and options[:group] == "wheel" }
         file.newchild("my/path")
       end
 
       it "should not copy default values to the new child" do
         @file.class.expects(:new).with { |params| params[:backup].nil? }
         @file.newchild("my/path")
       end
 
       it "should not copy values to the child which were set by the source" do
         @file[:source] = "/foo/bar"
         metadata = stub 'metadata', :owner => "root", :group => "root", :mode => 0755, :ftype => "file", :checksum => "{md5}whatever"
         @file.parameter(:source).stubs(:metadata).returns metadata
 
         @file.parameter(:source).copy_source_values
 
         @file.class.expects(:new).with { |params| params[:group].nil? }
         @file.newchild("my/path")
       end
     end
   end
 
   describe "when setting the backup" do
     it "should default to 'puppet'" do
       Puppet::Type::File.new(:name => "/my/file")[:backup].should == "puppet"
     end
 
     it "should allow setting backup to 'false'" do
       (!Puppet::Type::File.new(:name => "/my/file", :backup => false)[:backup]).should be_true
     end
 
     it "should set the backup to '.puppet-bak' if it is set to true" do
       Puppet::Type::File.new(:name => "/my/file", :backup => true)[:backup].should == ".puppet-bak"
     end
 
     it "should support any other backup extension" do
       Puppet::Type::File.new(:name => "/my/file", :backup => ".bak")[:backup].should == ".bak"
     end
 
     it "should set the filebucket when backup is set to a string matching the name of a filebucket in the catalog" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file")
       catalog.add_resource file
 
       file[:backup] = "foo"
       file.bucket.should == bucket_resource.bucket
     end
 
     it "should find filebuckets added to the catalog after the file resource was created" do
       catalog = Puppet::Resource::Catalog.new
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
       catalog.add_resource file
 
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file.bucket.should == bucket_resource.bucket
     end
 
     it "should have a nil filebucket if backup is false" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => false)
       catalog.add_resource file
 
       file.bucket.should be_nil
     end
 
     it "should have a nil filebucket if backup is set to a string starting with '.'" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => ".foo")
       catalog.add_resource file
 
       file.bucket.should be_nil
     end
 
     it "should fail if there's no catalog and backup is not false" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
 
       lambda { file.bucket }.should raise_error(Puppet::Error)
     end
 
     it "should fail if a non-existent catalog is specified" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       lambda { file.bucket }.should raise_error(Puppet::Error)
     end
 
     it "should be able to use the default filebucket without a catalog" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
       file.bucket.should be_instance_of(Puppet::FileBucket::Dipper)
     end
 
     it "should look up the filebucket during finish()" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => ".foo")
       file.expects(:bucket)
       file.finish
     end
   end
 
   describe "when retrieving the current file state" do
     it "should copy the source values if the 'source' parameter is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :source => "/foo/bar")
       file.parameter(:source).expects(:copy_source_values)
       file.retrieve
     end
   end
 
   describe ".title_patterns" do
     before do
       @type_class = Puppet::Type.type(:file)
     end
-    
+
     it "should have a regexp that captures the entire string, except for a terminating slash" do
       patterns = @type_class.title_patterns
       string = "abc/\n\tdef/"
       patterns[0][0] =~ string
       $1.should == "abc/\n\tdef"
     end
   end
 
 end
diff --git a/spec/unit/util/queue/stomp_spec.rb b/spec/unit/util/queue/stomp_spec.rb
index 9f1d28448..c33f1a670 100755
--- a/spec/unit/util/queue/stomp_spec.rb
+++ b/spec/unit/util/queue/stomp_spec.rb
@@ -1,140 +1,136 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'puppet/util/queue'
 
-describe Puppet::Util::Queue do
-  confine "Missing Stomp" => Puppet.features.stomp?
-
+describe Puppet::Util::Queue, :if => Puppet.features.stomp? do
   it 'should load :stomp client appropriately' do
     Puppet.settings.stubs(:value).returns 'faux_queue_source'
     Puppet::Util::Queue.queue_type_to_class(:stomp).name.should == 'Puppet::Util::Queue::Stomp'
   end
 end
 
-describe 'Puppet::Util::Queue::Stomp' do
-  confine "Missing Stomp" => Puppet.features.stomp?
-
+describe 'Puppet::Util::Queue::Stomp', :if => Puppet.features.stomp? do
   before do
     # So we make sure we never create a real client instance.
     # Otherwise we'll try to connect, and that's bad.
     Stomp::Client.stubs(:new).returns stub("client")
   end
 
   it 'should be registered with Puppet::Util::Queue as :stomp type' do
     Puppet::Util::Queue.queue_type_to_class(:stomp).should == Puppet::Util::Queue::Stomp
   end
 
   describe "when initializing" do
     it "should create a Stomp client instance" do
       Stomp::Client.expects(:new).returns stub("stomp_client")
       Puppet::Util::Queue::Stomp.new
     end
 
     it "should provide helpful failures when the queue source is not a valid source" do
       # Stub rather than expect, so we can include the source in the error
       Puppet.settings.stubs(:value).with(:queue_source).returns "-----"
 
       lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
     end
 
     it "should fail unless the queue source is a stomp URL" do
       # Stub rather than expect, so we can include the source in the error
       Puppet.settings.stubs(:value).with(:queue_source).returns "http://foo/bar"
 
       lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
     end
 
     it "should fail somewhat helpfully if the Stomp client cannot be created" do
       Stomp::Client.expects(:new).raises RuntimeError
       lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
     end
 
     list = %w{user password host port}
     {"user" => "myuser", "password" => "mypass", "host" => "foohost", "port" => 42}.each do |name, value|
       it "should use the #{name} from the queue source as the queueing #{name}" do
         Puppet.settings.expects(:value).with(:queue_source).returns "stomp://myuser:mypass@foohost:42/"
 
         Stomp::Client.expects(:new).with { |*args| args[list.index(name)] == value }
         Puppet::Util::Queue::Stomp.new
       end
     end
 
     it "should create a reliable client instance" do
       Puppet.settings.expects(:value).with(:queue_source).returns "stomp://myuser@foohost:42/"
 
       Stomp::Client.expects(:new).with { |*args| args[4] == true }
       Puppet::Util::Queue::Stomp.new
     end
   end
 
   describe "when sending a message" do
     before do
       @client = stub 'client'
       Stomp::Client.stubs(:new).returns @client
       @queue = Puppet::Util::Queue::Stomp.new
     end
 
     it "should send it to the queue client instance" do
       @client.expects(:send).with { |queue, msg, options| msg == "Smite!" }
       @queue.send_message('fooqueue', 'Smite!')
     end
 
     it "should send it to the transformed queue name" do
       @client.expects(:send).with { |queue, msg, options| queue == "/queue/fooqueue" }
       @queue.send_message('fooqueue', 'Smite!')
     end
 
     it "should send it as a persistent message" do
       @client.expects(:send).with { |queue, msg, options| options[:persistent] == true }
       @queue.send_message('fooqueue', 'Smite!')
     end
   end
 
   describe "when subscribing to a queue" do
     before do
       @client = stub 'client', :acknowledge => true
       Stomp::Client.stubs(:new).returns @client
       @queue = Puppet::Util::Queue::Stomp.new
     end
 
     it "should subscribe via the queue client instance" do
       @client.expects(:subscribe)
       @queue.subscribe('fooqueue')
     end
 
     it "should subscribe to the transformed queue name" do
       @client.expects(:subscribe).with { |queue, options| queue == "/queue/fooqueue" }
       @queue.subscribe('fooqueue')
     end
 
     it "should specify that its messages should be acknowledged" do
       @client.expects(:subscribe).with { |queue, options| options[:ack] == :client }
       @queue.subscribe('fooqueue')
     end
 
     it "should yield the body of any received message" do
       message = mock 'message'
       message.expects(:body).returns "mybody"
 
       @client.expects(:subscribe).yields(message)
 
       body = nil
       @queue.subscribe('fooqueue') { |b| body = b }
       body.should == "mybody"
     end
 
     it "should acknowledge all successfully processed messages" do
       message = stub 'message', :body => "mybode"
 
       @client.stubs(:subscribe).yields(message)
       @client.expects(:acknowledge).with(message)
 
       @queue.subscribe('fooqueue') { |b| "eh" }
     end
   end
 
   it 'should transform the simple queue name to "/queue/<queue_name>"' do
     Puppet::Util::Queue::Stomp.new.stompify_target('blah').should == '/queue/blah'
   end
 end
diff --git a/spec/unit/util/settings/file_setting_spec.rb b/spec/unit/util/settings/file_setting_spec.rb
index 2870fbb57..dcfb6e3b1 100755
--- a/spec/unit/util/settings/file_setting_spec.rb
+++ b/spec/unit/util/settings/file_setting_spec.rb
@@ -1,256 +1,254 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/util/settings'
 require 'puppet/util/settings/file_setting'
 
 describe Puppet::Util::Settings::FileSetting do
   FileSetting = Puppet::Util::Settings::FileSetting
 
   before do
     @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
   end
 
   describe "when determining whether the service user should be used" do
     before do
       @settings = mock 'settings'
       @settings.stubs(:[]).with(:mkusers).returns false
       @settings.stubs(:service_user_available?).returns true
     end
 
     it "should be true if the service user is available" do
       @settings.expects(:service_user_available?).returns true
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
 
     it "should be true if 'mkusers' is set" do
       @settings.expects(:[]).with(:mkusers).returns true
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
 
     it "should be false if the service user is not available and 'mkusers' is unset" do
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
   end
 
   describe "when setting the owner" do
     it "should allow the file to be owned by root" do
       root_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting") }
       root_owner.should_not raise_error
     end
 
     it "should allow the file to be owned by the service user" do
       service_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "service", :desc => "a setting") }
       service_owner.should_not raise_error
     end
 
     it "should allow the ownership of the file to be unspecified" do
       no_owner = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
       no_owner.should_not raise_error
     end
 
     it "should not allow other owners" do
       invalid_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "invalid", :desc => "a setting") }
       invalid_owner.should raise_error(FileSetting::SettingError)
     end
   end
 
   describe "when reading the owner" do
     it "should be root when the setting specifies root" do
       setting = FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting")
       setting.owner.should == "root"
     end
 
     it "should be the owner of the service when the setting specifies service and the service user should be used" do
       settings = mock("settings")
       settings.stubs(:[]).returns "the_service"
 
       setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
       setting.expects(:use_service_user?).returns true
       setting.owner.should == "the_service"
     end
 
     it "should be the root when the setting specifies service and the service user should not be used" do
       settings = mock("settings")
       settings.stubs(:[]).returns "the_service"
 
       setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
       setting.expects(:use_service_user?).returns false
       setting.owner.should == "root"
     end
 
     it "should be nil when the owner is unspecified" do
       FileSetting.new(:settings => mock("settings"), :desc => "a setting").owner.should be_nil
     end
   end
 
   describe "when setting the group" do
     it "should allow the group to be service" do
       service_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "service", :desc => "a setting") }
       service_group.should_not raise_error
     end
 
     it "should allow the group to be unspecified" do
       no_group = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
       no_group.should_not raise_error
     end
 
     it "should not allow invalid groups" do
       invalid_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "invalid", :desc => "a setting") }
       invalid_group.should raise_error(FileSetting::SettingError)
     end
   end
 
   describe "when reading the group" do
     it "should be service when the setting specifies service" do
       setting = FileSetting.new(:settings => mock("settings", :[] => "the_service"), :group => "service", :desc => "a setting")
       setting.group.should == "the_service"
     end
 
     it "should be nil when the group is unspecified" do
       FileSetting.new(:settings => mock("settings"), :desc => "a setting").group.should be_nil
     end
   end
 
   it "should be able to be converted into a resource" do
     FileSetting.new(:settings => mock("settings"), :desc => "eh").should respond_to(:to_resource)
   end
 
   describe "when being converted to a resource" do
     before do
       @settings = mock 'settings'
       @file = Puppet::Util::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
       @settings.stubs(:value).with(:mydir).returns @basepath
     end
 
     it "should skip files that cannot determine their types" do
       @file.expects(:type).returns nil
       @file.to_resource.should be_nil
     end
 
     it "should skip non-existent files if 'create_files' is not enabled" do
       @file.expects(:create_files?).returns false
       @file.expects(:type).returns :file
       File.expects(:exist?).with(@basepath).returns false
       @file.to_resource.should be_nil
     end
 
     it "should manage existent files even if 'create_files' is not enabled" do
       @file.expects(:create_files?).returns false
       @file.expects(:type).returns :file
       File.expects(:exist?).with(@basepath).returns true
       @file.to_resource.should be_instance_of(Puppet::Resource)
     end
 
-    describe "on POSIX systems" do
-      confine "no /dev on Microsoft Windows" => Puppet.features.posix?
-
+    describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should skip files in /dev" do
         @settings.stubs(:value).with(:mydir).returns "/dev/file"
         @file.to_resource.should be_nil
       end
     end
 
     it "should skip files whose paths are not strings" do
       @settings.stubs(:value).with(:mydir).returns :foo
       @file.to_resource.should be_nil
     end
 
     it "should return a file resource with the path set appropriately" do
       resource = @file.to_resource
       resource.type.should == "File"
       resource.title.should == @basepath
     end
 
     it "should fully qualified returned files if necessary (#795)" do
       @settings.stubs(:value).with(:mydir).returns "myfile"
       @file.to_resource.title.should == File.join(Dir.getwd, "myfile")
     end
 
     it "should set the mode on the file if a mode is provided" do
       @file.mode = 0755
 
       @file.to_resource[:mode].should == 0755
     end
 
     it "should not set the mode on a the file if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
 
       @file.stubs(:mode).returns(0755)
 
       @file.to_resource[:mode].should == nil
     end
 
     it "should set the owner if running as root and the owner is provided" do
       Puppet.features.expects(:root?).returns true
       @file.stubs(:owner).returns "foo"
       @file.to_resource[:owner].should == "foo"
     end
 
     it "should not set the owner if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
       Puppet.features.stubs(:root?).returns true
       @file.stubs(:owner).returns "foo"
 
       @file.to_resource[:owner].should == nil
     end
 
     it "should set the group if running as root and the group is provided" do
       Puppet.features.expects(:root?).returns true
       @file.stubs(:group).returns "foo"
       @file.to_resource[:group].should == "foo"
     end
 
     it "should not set the group if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
       Puppet.features.stubs(:root?).returns true
       @file.stubs(:group).returns "foo"
 
       @file.to_resource[:group].should == nil
     end
 
 
     it "should not set owner if not running as root" do
       Puppet.features.expects(:root?).returns false
       @file.stubs(:owner).returns "foo"
       @file.to_resource[:owner].should be_nil
     end
 
     it "should not set group if not running as root" do
       Puppet.features.expects(:root?).returns false
       @file.stubs(:group).returns "foo"
       @file.to_resource[:group].should be_nil
     end
 
     it "should set :ensure to the file type" do
       @file.expects(:type).returns :directory
       @file.to_resource[:ensure].should == :directory
     end
 
     it "should set the loglevel to :debug" do
       @file.to_resource[:loglevel].should == :debug
     end
 
     it "should set the backup to false" do
       @file.to_resource[:backup].should be_false
     end
 
     it "should tag the resource with the settings section" do
       @file.expects(:section).returns "mysect"
       @file.to_resource.should be_tagged("mysect")
     end
 
     it "should tag the resource with the setting name" do
       @file.to_resource.should be_tagged("mydir")
     end
 
     it "should tag the resource with 'settings'" do
       @file.to_resource.should be_tagged("settings")
     end
   end
 end