diff --git a/test/executables/filebucket.rb b/test/executables/filebucket.rb
index 491630707..f479c150e 100755
--- a/test/executables/filebucket.rb
+++ b/test/executables/filebucket.rb
@@ -1,48 +1,51 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppet/network/client'
 require 'puppettest'
 require 'socket'
 require 'facter'
 
 class TestFileBucketExe < Test::Unit::TestCase
     include PuppetTest::ExeTest
 
     def test_local
+        basedir = tempfile()
+        FileUtils.mkdir_p(basedir)
+
         bucket = tempfile
         file = tempfile
         text = "somet ext"
         md5 = Digest::MD5.hexdigest(text)
         File.open(file, "w") { |f| f.print text }
-        out = %x{filebucket --bucket #{bucket} backup #{file}}
+        out = %x{filebucket --confdir #{basedir} --vardir #{basedir} --bucket #{bucket} backup #{file}}
 
         outfile, outmd5 = out.chomp.split(": ")
 
         assert_equal(0, $?, "filebucket did not run successfully")
 
         assert_equal(file, outfile, "did not output correct file name")
         assert_equal(md5, outmd5, "did not output correct md5 sum")
 
         dipper = Puppet::Network::Client.dipper.new(:Path => bucket)
 
         newtext = nil
         assert_nothing_raised("Could not get file from bucket") do
             newtext = dipper.getfile(md5)
         end
 
         assert_equal(text, newtext, "did not get correct file from md5 sum")
 
-        out = %x{filebucket --bucket #{bucket} get #{md5}}
+        out = %x{filebucket --confdir #{basedir} --vardir #{basedir} --bucket #{bucket} get #{md5}}
         assert_equal(0, $?, "filebucket did not run successfully")
         assert_equal(text, out, "did not get correct text back from filebucket")
 
         File.open(file, "w") { |f| f.puts "some other txt" }
-        out = %x{filebucket --bucket #{bucket} restore #{file} #{md5}}
+        out = %x{filebucket --confdir #{basedir} --vardir #{basedir} --bucket #{bucket} restore #{file} #{md5}}
         assert_equal(0, $?, "filebucket did not run successfully")
         assert_equal(text, File.read(file), "file was not restored")
     end
 end
 
diff --git a/test/executables/puppetbin.rb b/test/executables/puppetbin.rb
index 08329efb6..631b3b22a 100755
--- a/test/executables/puppetbin.rb
+++ b/test/executables/puppetbin.rb
@@ -1,104 +1,104 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppettest'
 
 class TestPuppetBin < Test::Unit::TestCase
     include PuppetTest::ExeTest
     def test_version
         output = nil
         assert_nothing_raised {
           output = %x{puppet --version}.chomp
         }
         assert_equal(Puppet.version, output)
     end
 
     def test_execution
         file = mktestmanifest()
 
         output = nil
         cmd = "puppet"
         if Puppet[:debug]
             cmd += " --debug"
         end
         cmd += " --confdir %s" % Puppet[:confdir]
         cmd += " --vardir %s" % Puppet[:vardir]
         unless Puppet[:debug]
             cmd += " --logdest %s" % "/dev/null"
         end
 
         assert_nothing_raised {
             output = %x{#{cmd + " " + file} 2>&1}
         }
         assert($? == 0, "Puppet exited with code %s" % $?.to_i)
 
         assert(FileTest.exists?(@createdfile), "Failed to create config'ed file")
     end
 
     def test_inlineexecution
         path = tempfile()
         code = "file { '#{path}': ensure => file }"
 
         output = nil
         cmd = "puppet"
         if Puppet[:debug]
             cmd += " --debug"
         end
         #cmd += " --fqdn %s" % fqdn
         cmd += " --confdir %s" % Puppet[:confdir]
         cmd += " --vardir %s" % Puppet[:vardir]
         unless Puppet[:debug]
             cmd += " --logdest %s" % "/dev/null"
         end
 
         cmd += " -e \"#{code}\""
 
         assert_nothing_raised {
             out = %x{#{cmd} 2>&1}
         }
         assert($? == 0, "Puppet exited with code %s" % $?.to_i)
 
         assert(FileTest.exists?(path), "Failed to create config'ed file")
     end
 
     def test_stdin_execution
         path = tempfile()
         manifest = tempfile()
         env = %x{which env}.chomp
         if env == ""
             Puppet.info "cannot find env; cannot test stdin_execution"
             return
         end
         File.open(manifest, "w") do |f|
             f.puts "#!#{env} puppet
-            file { '#{path}': ensure => file }"
+            exec { '/bin/touch #{path}': }"
         end
         File.chmod(0755, manifest)
 
         assert_nothing_raised {
             out = %x{#{manifest} 2>&1}
         }
         assert($? == 0, "manifest exited with code %s" % $?.to_i)
 
         assert(FileTest.exists?(path), "Failed to create config'ed file")
     end
 
     def test_parseonly
         path = tempfile()
         manifest = tempfile()
         puppet = %x{which puppet}.chomp
         if puppet == ""
             Puppet.info "cannot find puppet; cannot test parseonly"
             return
         end
         code = 'File <<| |>>
         include nosuchclass'
 
         assert_nothing_raised {
             IO.popen("#{puppet} --parseonly", 'w') { |p| p.puts code }
         }
         assert($? == 0, "parseonly test exited with code %s" % $?.to_i)
     end
 end
 
diff --git a/test/lib/puppettest.rb b/test/lib/puppettest.rb
index 63f8121b5..7fb98ef1d 100755
--- a/test/lib/puppettest.rb
+++ b/test/lib/puppettest.rb
@@ -1,344 +1,347 @@
 # Add .../test/lib
 testlib = File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH.unshift(testlib) unless $LOAD_PATH.include?(testlib)
 # Add .../lib
 mainlib = File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
 $LOAD_PATH.unshift(mainlib) unless $LOAD_PATH.include?(mainlib)
 
 require 'puppet'
 
 # include any gems in vendor/gems
 Dir["#{mainlib}/../vendor/gems/**"].each do |path| 
     libpath = File.join(path, "lib")
     if File.directory?(libpath)
         $LOAD_PATH.unshift(libpath)
     else
         $LOAD_PATH.unshift(path)
     end
 end
 
 require 'mocha'
 
 # Only load the test/unit class if we're not in the spec directory.
 # Else we get the bogus 'no tests, no failures' message.
 unless Dir.getwd =~ /spec/
     require 'test/unit'
 end
 
 # Yay; hackish but it works
 if ARGV.include?("-d")
     ARGV.delete("-d")
     $console = true
 end
 
 # Some monkey-patching to allow us to test private methods.
 class Class
     def publicize_methods(*methods)
         saved_private_instance_methods = methods.empty? ? self.private_instance_methods : methods
 
         self.class_eval { public(*saved_private_instance_methods) }
         yield
         self.class_eval { private(*saved_private_instance_methods) }
     end
 end
 
 module PuppetTest
     # These need to be here for when rspec tests use these
     # support methods.
     @@tmpfiles = []
 
     # Munge cli arguments, so we can enable debugging if we want
     # and so we can run just specific methods.
     def self.munge_argv
         require 'getoptlong'
 
         result = GetoptLong.new(
             [ "--debug",	"-d",			GetoptLong::NO_ARGUMENT ],
             [ "--resolve",	"-r",			GetoptLong::REQUIRED_ARGUMENT ],
             [ "-n",			                GetoptLong::REQUIRED_ARGUMENT ],
             [ "--help",		"-h",			GetoptLong::NO_ARGUMENT ]
         )
 
         usage = "USAGE: TESTOPTS='[-n <method> -n <method> ...] [-d]' rake [target] [target] ..."
 
         opts = []
 
         dir = method = nil
         result.each { |opt,arg|
             case opt
             when "--resolve"
                 dir, method = arg.split(",")
             when "--debug"
                 $puppet_debug = true
                 Puppet::Util::Log.level = :debug
                 Puppet::Util::Log.newdestination(:console)
             when "--help"
                 puts usage
                 exit
             else
                 opts << opt << arg
             end
         }
         suites = nil
 
         args = ARGV.dup
 
         # Reset the options, so the test suite can deal with them (this is
         # what makes things like '-n' work).
         opts.each { |o| ARGV << o }
 
         return args
     end
 
     # Find the root of the Puppet tree; this is not the test directory, but
     # the parent of that dir.
     def basedir(*list)
         unless defined? @@basedir
             Dir.chdir(File.dirname(__FILE__)) do
                 @@basedir = File.dirname(File.dirname(Dir.getwd))
             end
         end
         if list.empty?
             @@basedir
         else
             File.join(@@basedir, *list)
         end
     end
 
     def datadir(*list)
         File.join(basedir, "test", "data", *list)
     end
 
     def exampledir(*args)
         unless defined? @@exampledir
             @@exampledir = File.join(basedir, "examples")
         end
 
         if args.empty?
             return @@exampledir
         else
             return File.join(@@exampledir, *args)
         end
     end
 
     module_function :basedir, :datadir, :exampledir
 
     def cleanup(&block)
         @@cleaners << block
     end
 
     # Rails clobbers RUBYLIB, thanks
     def libsetup
         curlibs = ENV["RUBYLIB"].split(":")
         $:.reject do |dir| dir =~ /^\/usr/ end.each do |dir|
             unless curlibs.include?(dir)
                 curlibs << dir
             end
         end
 
         ENV["RUBYLIB"] = curlibs.join(":")
     end
     
     def logcollector
         collector = []
         Puppet::Util::Log.newdestination(collector)
         cleanup do
             Puppet::Util::Log.close(collector)
         end
         collector
     end
 
     def rake?
         $0 =~ /test_loader/
     end
 
     # Redirect stdout and stderr
     def redirect
         @stderr = tempfile
         @stdout = tempfile
         $stderr = File.open(@stderr, "w")
         $stdout = File.open(@stdout, "w")
 
         cleanup do
             $stderr = STDERR
             $stdout = STDOUT
         end
     end
 
     def setup
+        unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
+            ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin"
+        end
         @memoryatstart = Puppet::Util.memory
         if defined? @@testcount
             @@testcount += 1
         else
             @@testcount = 0
         end
 
         @configpath = File.join(tmpdir,
             "configdir" + @@testcount.to_s + "/"
         )
 
         unless defined? $user and $group
             $user = nonrootuser().uid.to_s
             $group = nonrootgroup().gid.to_s
         end
 
         Puppet.settings.clear
         Puppet[:user] = $user
         Puppet[:group] = $group
 
         Puppet[:confdir] = @configpath
         Puppet[:vardir] = @configpath
 
         unless File.exists?(@configpath)
             Dir.mkdir(@configpath)
         end
 
         @@tmpfiles << @configpath << tmpdir()
         @@tmppids = []
 
         @@cleaners = []
 
         @logs = []
 
         # If we're running under rake, then disable debugging and such.
         #if rake? or ! Puppet[:debug]
         #if defined?($puppet_debug) or ! rake?
             if textmate?
                 Puppet[:color] = false
             end
             Puppet::Util::Log.newdestination(@logs)
             if defined? $console
                 Puppet.info @method_name
                 Puppet::Util::Log.newdestination(:console)
                 Puppet[:trace] = true
             end
             Puppet::Util::Log.level = :debug
             #$VERBOSE = 1
         #else    
         #    Puppet::Util::Log.close
         #    Puppet::Util::Log.newdestination(@logs)
         #    Puppet[:httplog] = tempfile()
         #end
 
         Puppet[:ignoreschedules] = true
 
         #@start = Time.now
     end
 
     def tempfile
         if defined? @@tmpfilenum
             @@tmpfilenum += 1
         else
             @@tmpfilenum = 1
         end
 
         f = File.join(self.tmpdir(), "tempfile_" + @@tmpfilenum.to_s)
         @@tmpfiles << f
         return f
     end
     
     def textmate?
         if ENV["TM_FILENAME"]
             return true
         else
             return false
         end
     end
 
     def tstdir
         dir = tempfile()
         Dir.mkdir(dir)
         return dir
     end
 
     def tmpdir
         unless defined? @tmpdir and @tmpdir
             @tmpdir = case Facter["operatingsystem"].value
                       when "Darwin": "/private/tmp"
                       when "SunOS": "/var/tmp"
                       else
                             "/tmp"
                       end
 
 
             @tmpdir = File.join(@tmpdir, "puppettesting" + Process.pid.to_s)
 
             unless File.exists?(@tmpdir)
                 FileUtils.mkdir_p(@tmpdir)
                 File.chmod(01777, @tmpdir)
             end
         end
         @tmpdir
     end
 
     def remove_tmp_files
         @@tmpfiles.each { |file|
             unless file =~ /tmp/
                 puts "Not deleting tmpfile %s" % file
                 next
             end
             if FileTest.exists?(file)
                 system("chmod -R 755 %s" % file)
                 system("rm -rf %s" % file)
             end
         }
         @@tmpfiles.clear
     end
 
     def teardown
         #@stop = Time.now
         #File.open("/tmp/test_times.log", ::File::WRONLY|::File::CREAT|::File::APPEND) { |f| f.puts "%0.4f %s %s" % [@stop - @start, @method_name, self.class] }
         @@cleaners.each { |cleaner| cleaner.call() }
 
         remove_tmp_files
 
         @@tmppids.each { |pid|
             %x{kill -INT #{pid} 2>/dev/null}
         }
 
         @@tmppids.clear
 
         Puppet::Type.allclear
         Puppet::Util::Storage.clear
         Puppet.clear
         Puppet.settings.clear
         Puppet::Indirector::Indirection.clear_cache
 
         @memoryatend = Puppet::Util.memory
         diff = @memoryatend - @memoryatstart
 
         if diff > 1000
             Puppet.info "%s#%s memory growth (%s to %s): %s" %
                 [self.class, @method_name, @memoryatstart, @memoryatend, diff]
         end
 
         # reset all of the logs
         Puppet::Util::Log.close
         @logs.clear
 
         # Just in case there are processes waiting to die...
         require 'timeout'
 
         begin
             Timeout::timeout(5) do
                 Process.waitall
             end
         rescue Timeout::Error
             # just move on
         end
     end
 
     def logstore
         @logs = []
         Puppet::Util::Log.newdestination(@logs)
     end
 end
 
 require 'puppettest/support'
 require 'puppettest/filetesting'
 require 'puppettest/fakes'
 require 'puppettest/exetest'
 require 'puppettest/parsertesting'
 require 'puppettest/servertest'
 require 'puppettest/testcase'