diff --git a/lib/puppet/provider/package/darwinport.rb b/lib/puppet/provider/package/darwinport.rb
deleted file mode 100755
index c5f9ba28f..000000000
--- a/lib/puppet/provider/package/darwinport.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-require 'puppet/provider/package'
-
-Puppet::Type.type(:package).provide :darwinport, :parent => Puppet::Provider::Package do
-  desc "Package management using DarwinPorts on OS X."
-
-  confine :operatingsystem => :darwin
-  commands :port => "/opt/local/bin/port"
-
-  def self.eachpkgashash
-    # list out all of the packages
-    open("| #{command(:port)} list installed") { |process|
-      regex = %r{(\S+)\s+@(\S+)\s+(\S+)}
-      fields = [:name, :ensure, :location]
-      hash = {}
-
-      # now turn each returned line into a package object
-      process.each { |line|
-        hash.clear
-
-        if match = regex.match(line)
-          fields.zip(match.captures) { |field,value|
-            hash[field] = value
-          }
-
-          hash.delete :location
-          hash[:provider] = self.name
-          yield hash.dup
-        else
-          raise Puppet::DevError,
-            "Failed to match dpkg line #{line}"
-        end
-      }
-    }
-  end
-
-  def self.instances
-    packages = []
-
-    eachpkgashash do |hash|
-      packages << new(hash)
-    end
-
-    packages
-  end
-
-  def install
-    should = @resource.should(:ensure)
-
-    # Seems like you can always say 'upgrade'
-    output = port "upgrade", @resource[:name]
-    if output =~ /^Error: No port/
-      raise Puppet::ExecutionFailure, "Could not find package #{@resource[:name]}"
-    end
-  end
-
-  def query
-    version = nil
-    self.class.eachpkgashash do |hash|
-      return hash if hash[:name] == @resource[:name]
-    end
-
-    nil
-  end
-
-  def latest
-    info = port :search, "^#{@resource[:name]}$"
-
-    if $CHILD_STATUS != 0 or info =~ /^Error/
-      return nil
-    end
-
-    ary = info.split(/\s+/)
-    version = ary[2].sub(/^@/, '')
-
-    version
-  end
-
-  def uninstall
-    port :uninstall, @resource[:name]
-  end
-
-  def update
-    install
-  end
-end
-
diff --git a/spec/lib/puppet_spec/files.rb b/spec/lib/puppet_spec/files.rb
index 38c51a572..30fb4fc42 100644
--- a/spec/lib/puppet_spec/files.rb
+++ b/spec/lib/puppet_spec/files.rb
@@ -1,43 +1,53 @@
 require 'fileutils'
 require 'tempfile'
 
 # A support module for testing files.
 module PuppetSpec::Files
+  # This code exists only to support tests that run as root, pretty much.
+  # Once they have finally been eliminated this can all go... --daniel 2011-04-08
+  if Puppet.features.posix? then
+    def self.in_tmp(path)
+      path =~ /^\/tmp/ or path =~ /^\/var\/folders/
+    end
+  elsif Puppet.features.microsoft_windows?
+    def self.in_tmp(path)
+      tempdir = File.expand_path(File.join(Dir::LOCAL_APPDATA, "Temp"))
+      path =~ /^#{tempdir}/
+    end
+  else
+    fail "Help! Can't find in_tmp for this platform"
+  end
+
   def self.cleanup
-    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
+    $global_tempfiles ||= []
+    while path = $global_tempfiles.pop do
+      fail "Not deleting tmpfile #{path} outside regular tmpdir" unless in_tmp(path)
+
+      begin
+        FileUtils.rm_r path, :secure => true
+      rescue Errno::ENOENT
+        # nothing to do
       end
-      $tmpfiles.clear
     end
   end
 
   def tmpfile(name)
+    # Generate a temporary file, just for the name...
     source = Tempfile.new(name)
     path = source.path
     source.close!
-    $tmpfiles ||= []
-    $tmpfiles << path
+
+    # ...record it for cleanup,
+    $global_tempfiles ||= []
+    $global_tempfiles << File.expand_path(path)
+
+    # ...and bam.
     path
   end
 
   def tmpdir(name)
-    file = tmpfile(name)
-    FileUtils.mkdir_p(file)
-    file
+    path = tmpfile(name)
+    FileUtils.mkdir_p(path)
+    path
   end
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index fc63c6d19..e8ab66611 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,72 +1,76 @@
 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', '>=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 'pathname'
 require 'tmpdir'
 
 require 'lib/puppet_spec/verbose'
 require 'lib/puppet_spec/files'
 require 'lib/puppet_spec/fixtures'
 require 'monkey_patches/alias_should_to_must'
 require 'monkey_patches/publicize_methods'
 
 Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
   require behaviour.relative_path_from(Pathname.new(dir))
 end
 
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 
   config.mock_with :mocha
 
   config.before :each do
+    GC.disable
+
     # these globals are set by Application
     $puppet_application_mode = nil
     $puppet_application_name = nil
     Signal.stubs(:trap)
 
     # 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(Puppet::Test::LogCollector.new(@logs))
   end
 
   config.after :each do
     Puppet.settings.clear
     Puppet::Node::Environment.clear
     Puppet::Util::Storage.clear
     Puppet::Util::ExecutionStub.reset
 
     PuppetSpec::Files.cleanup
 
     @logs.clear
     Puppet::Util::Log.close_all
+
+    GC.enable
   end
 end
 
 # close of the "don't evaluate twice" mess.
 end
diff --git a/spec/unit/application/faces_base_spec.rb b/spec/unit/application/faces_base_spec.rb
index 6d8815f44..6d8456612 100755
--- a/spec/unit/application/faces_base_spec.rb
+++ b/spec/unit/application/faces_base_spec.rb
@@ -1,185 +1,192 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper.rb')
 require 'puppet/application/faces_base'
 require 'tmpdir'
 
 class Puppet::Application::FacesBase::Basetest < Puppet::Application::FacesBase
 end
 
 describe Puppet::Application::FacesBase do
   before :all do
     @dir = Dir.mktmpdir
     $LOAD_PATH.push(@dir)
     FileUtils.mkdir_p(File.join @dir, 'puppet', 'faces')
     File.open(File.join(@dir, 'puppet', 'faces', 'basetest.rb'), 'w') do |f|
       f.puts "Puppet::Faces.define(:basetest, '0.0.1')"
     end
 
     Puppet::Faces.define(:basetest, '0.0.1') do
       option("--[no-]boolean")
       option("--mandatory MANDATORY")
       option("--optional [OPTIONAL]")
 
       action :foo do
         option("--action")
         when_invoked { |*args| args.length }
       end
     end
   end
 
   after :all do
     FileUtils.remove_entry_secure @dir
     $LOAD_PATH.pop
   end
 
   let :app do
     app = Puppet::Application::FacesBase::Basetest.new
     app.stubs(:exit)
     app.stubs(:puts)
     app.command_line.stubs(:subcommand_name).returns 'subcommand'
     Puppet::Util::Log.stubs(:newdestination)
     app
   end
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
       app.find_global_settings_argument("--ca-location").should be_nil
     end
   end
 
   describe "#preinit" do
     before :each do
       app.command_line.stubs(:args).returns %w{}
     end
 
     describe "parsing the command line" do
       context "with just an action" do
         before :all do
+          # We have to stub Signal.trap to avoid a crazy mess where we take
+          # over signal handling and make it impossible to cancel the test
+          # suite run.
+          #
+          # It would be nice to fix this elsewhere, but it is actually hard to
+          # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
+          Signal.stubs(:trap)
           app.command_line.stubs(:args).returns %w{foo}
           app.preinit
         end
 
         it "should set the faces based on the type" do
           app.face.name.should == :basetest
         end
 
         it "should set the format based on the faces default" do
           app.format.should == :pson
         end
 
         it "should find the action" do
           app.action.should be
           app.action.name.should == :foo
         end
       end
 
       it "should fail if no action is given" do
         expect { app.preinit }.
           should raise_error ArgumentError, /No action given/
       end
 
       it "should report a sensible error when options with = fail" do
         app.command_line.stubs(:args).returns %w{--action=bar foo}
         expect { app.preinit }.
           should raise_error ArgumentError, /Unknown option "--action"/
       end
 
       it "should fail if an action option is before the action" do
         app.command_line.stubs(:args).returns %w{--action foo}
         expect { app.preinit }.
           should raise_error ArgumentError, /Unknown option "--action"/
       end
 
       it "should fail if an unknown option is before the action" do
         app.command_line.stubs(:args).returns %w{--bar foo}
         expect { app.preinit }.
           should raise_error ArgumentError, /Unknown option "--bar"/
       end
 
       it "should not fail if an unknown option is after the action" do
         app.command_line.stubs(:args).returns %w{foo --bar}
         app.preinit
         app.action.name.should == :foo
         app.face.should_not be_option :bar
         app.action.should_not be_option :bar
       end
 
       it "should accept --bar as an argument to a mandatory option after action" do
         app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
         app.preinit and app.parse_options
         app.action.name.should == :foo
         app.options.should == { :mandatory => "--bar" }
       end
 
       it "should accept --bar as an argument to a mandatory option before action" do
         app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
         app.preinit and app.parse_options
         app.action.name.should == :foo
         app.options.should == { :mandatory => "--bar" }
       end
 
       it "should not skip when --foo=bar is given" do
         app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
         expect { app.preinit }.
           should raise_error ArgumentError, /Unknown option "--bar"/
       end
 
       { "boolean options before" => %w{--trace foo},
         "boolean options after"  => %w{foo --trace}
       }.each do |name, args|
         it "should accept global boolean settings #{name} the action" do
           app.command_line.stubs(:args).returns args
           app.preinit && app.parse_options
           Puppet[:trace].should be_true
         end
       end
 
       { "before" => %w{--syslogfacility user1 foo},
         " after" => %w{foo --syslogfacility user1}
       }.each do |name, args|
         it "should accept global settings with arguments #{name} the action" do
           app.command_line.stubs(:args).returns args
           app.preinit && app.parse_options
           Puppet[:syslogfacility].should == "user1"
         end
       end
     end
   end
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit and app.parse_options and app.setup
       app.arguments.should == [{ :mandatory => "--bar" }]
     end
 
     it "should pass positional arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo bar baz quux}
       app.preinit and app.parse_options and app.setup
       app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
     end
   end
 
   describe "#main" do
     before do
       app.face      = Puppet::Faces[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
       app.format    = :pson
       app.arguments = ["myname", "myarg"]
     end
 
     it "should send the specified verb and name to the faces" do
       app.face.expects(:foo).with(*app.arguments)
       app.main
     end
 
     it "should use its render method to render any result" do
       app.expects(:render).with(app.arguments.length + 1)
       app.main
     end
   end
 end