diff --git a/spec/unit/application/resource_spec.rb b/spec/unit/application/resource_spec.rb
index 01cd17e00..b6ed8598d 100755
--- a/spec/unit/application/resource_spec.rb
+++ b/spec/unit/application/resource_spec.rb
@@ -1,249 +1,250 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/resource'
 
 describe Puppet::Application::Resource do
   before :each do
     @resource = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
     @resource.should_parse_config?.should be_false
   end
 
   it "should declare a main command" do
     @resource.should respond_to(:main)
   end
 
   it "should declare a host option" do
     @resource.should respond_to(:handle_host)
   end
 
   it "should declare a types option" do
     @resource.should respond_to(:handle_types)
   end
 
   it "should declare a param option" do
     @resource.should respond_to(:handle_param)
   end
 
   it "should declare a preinit block" do
     @resource.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     it "should set hosts to nil", :'fails_on_ruby_1.9.2' => true do
       @resource.preinit
 
       @resource.host.should be_nil
     end
 
     it "should init extra_params to empty array", :'fails_on_ruby_1.9.2' => true do
       @resource.preinit
 
       @resource.extra_params.should == []
     end
 
     it "should load Facter facts" do
       Facter.expects(:loadfacts).once
       @resource.preinit
     end
   end
 
   describe "when handling options" do
 
     [:debug, :verbose, :edit].each do |option|
       it "should declare handle_#{option} method" do
         @resource.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @resource.options.expects(:[]=).with(option, 'arg')
         @resource.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set options[:host] to given host" do
       @resource.handle_host(:whatever)
 
       @resource.host.should == :whatever
     end
 
     it "should load an display all types with types option" do
       type1 = stub_everything 'type1', :name => :type1
       type2 = stub_everything 'type2', :name => :type2
       Puppet::Type.stubs(:loadall)
       Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
       @resource.expects(:puts).with(['type1','type2'])
       expect { @resource.handle_types(nil) }.to exit_with 0
     end
 
     it "should add param to extra_params list" do
       @resource.extra_params = [ :param1 ]
       @resource.handle_param("whatever")
 
       @resource.extra_params.should == [ :param1, :whatever ]
     end
   end
 
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:parse_config)
     end
 
 
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @resource.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @resource.options.stubs(:[]).with(:debug).returns(true)
       @resource.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @resource.options.stubs(:[]).with(:debug).returns(false)
       @resource.options.stubs(:[]).with(:verbose).returns(true)
       @resource.setup
       Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
       @resource.setup
     end
   end
 
   describe "when running" do
 
     before :each do
       @type = stub_everything 'type', :properties => []
       @resource.command_line.stubs(:args).returns(['type'])
       Puppet::Type.stubs(:type).returns(@type)
     end
 
     it "should raise an error if no type is given" do
       @resource.command_line.stubs(:args).returns([])
       lambda { @resource.main }.should raise_error
     end
 
     it "should raise an error when editing a remote host" do
       @resource.options.stubs(:[]).with(:edit).returns(true)
       @resource.host = 'host'
 
       lambda { @resource.main }.should raise_error
     end
 
     it "should raise an error if the type is not found" do
       Puppet::Type.stubs(:type).returns(nil)
 
       lambda { @resource.main }.should raise_error
     end
 
     describe "with a host" do
       before :each do
         @resource.stubs(:puts)
         @resource.host = 'host'
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
         @resource.command_line.stubs(:args).returns(['type'])
         Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
         @resource.main
       end
 
       it "should describe the given resource" do
         @resource.command_line.stubs(:args).returns(['type', 'name'])
         x = stub_everything 'resource'
         Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(x)
         @resource.main
       end
 
       it "should add given parameters to the object" do
         @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
 
         res = stub "resource"
         Puppet::Resource.indirection.expects(:save).with(res, 'https://host:8139/production/resources/type/name').returns(res)
         res.expects(:collect)
         res.expects(:to_manifest)
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
 
         @resource.main
       end
 
     end
 
     describe "without a host" do
       before :each do
         @resource.stubs(:puts)
         @resource.host = nil
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
         Puppet::Resource.indirection.expects(:search).with('type/', {}).returns([])
         @resource.main
       end
 
       it "should describe the given resource" do
         @resource.command_line.stubs(:args).returns(['type','name'])
         x = stub_everything 'resource'
         Puppet::Resource.indirection.expects(:find).with('type/name').returns(x)
         @resource.main
       end
 
       it "should add given parameters to the object" do
         @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
 
         res = stub "resource"
         Puppet::Resource.indirection.expects(:save).with(res, 'type/name').returns(res)
         res.expects(:collect)
         res.expects(:to_manifest)
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
 
         @resource.main
       end
 
     end
   end
 
   describe "when handling file type" do
     before :each do
       Facter.stubs(:loadfacts)
       @resource.preinit
     end
 
     it "should raise an exception if no file specified" do
       @resource.command_line.stubs(:args).returns(['file'])
 
       lambda { @resource.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
     end
 
     it "should output a file resource when given a file path" do
-      res = Puppet::Type.type(:file).new(:path => "/etc").to_resource
+      path = File.expand_path('/etc')
+      res = Puppet::Type.type(:file).new(:path => path).to_resource
       Puppet::Resource.indirection.expects(:find).returns(res)
 
-      @resource.command_line.stubs(:args).returns(['file', '/etc'])
+      @resource.command_line.stubs(:args).returns(['file', path])
       @resource.expects(:puts).with do |args|
-        args.should =~ /file \{ '\/etc'/m
+        args.should =~ /file \{ '#{Regexp.escape(path)}'/m
       end
 
       @resource.main
     end
   end
 end
diff --git a/spec/unit/util/suidmanager_spec.rb b/spec/unit/util/suidmanager_spec.rb
index fc70e1718..abfe3f723 100755
--- a/spec/unit/util/suidmanager_spec.rb
+++ b/spec/unit/util/suidmanager_spec.rb
@@ -1,210 +1,213 @@
 #!/usr/bin/env rspec
 
 require 'spec_helper'
 
 describe Puppet::Util::SUIDManager do
   let :user do
     Puppet::Type.type(:user).new(:name => 'name', :uid => 42, :gid => 42)
   end
 
   let :xids do
     Hash.new {|h,k| 0}
   end
 
   before :each do
     Puppet::Util::SUIDManager.stubs(:convert_xid).returns(42)
     Puppet::Util::SUIDManager.stubs(:initgroups)
 
     [:euid, :egid, :uid, :gid, :groups].each do |id|
       Process.stubs("#{id}=").with {|value| xids[id] = value}
     end
   end
 
   describe "#uid" do
     it "should allow setting euid/egid" do
       Puppet::Util::SUIDManager.egid = user[:gid]
       Puppet::Util::SUIDManager.euid = user[:uid]
 
       xids[:egid].should == user[:gid]
       xids[:euid].should == user[:uid]
     end
   end
 
   describe "#asuser" do
     it "should set euid/egid when root" do
       Process.stubs(:uid).returns(0)
+      Puppet.features.stubs(:microsoft_windows?).returns(false)
 
       Process.stubs(:egid).returns(51)
       Process.stubs(:euid).returns(50)
 
       Puppet::Util::SUIDManager.stubs(:convert_xid).with(:gid, 51).returns(51)
       Puppet::Util::SUIDManager.stubs(:convert_xid).with(:uid, 50).returns(50)
 
       yielded = false
       Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) do
         xids[:egid].should == user[:gid]
         xids[:euid].should == user[:uid]
         yielded = true
       end
 
       xids[:egid].should == 51
       xids[:euid].should == 50
 
       # It's possible asuser could simply not yield, so the assertions in the
       # block wouldn't fail. So verify those actually got checked.
       yielded.should be_true
     end
 
     it "should not get or set euid/egid when not root" do
       Process.stubs(:uid).returns(1)
 
       Process.stubs(:egid).returns(51)
       Process.stubs(:euid).returns(50)
 
       Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
 
       xids.should be_empty
     end
   end
 
   describe "#change_group" do
     describe "when changing permanently" do
       it "should try to change_privilege if it is supported" do
         Process::GID.expects(:change_privilege).with do |gid|
           Process.gid = gid
           Process.egid = gid
         end
 
         Puppet::Util::SUIDManager.change_group(42, true)
 
         xids[:egid].should == 42
         xids[:gid].should == 42
       end
 
       it "should change both egid and gid if change_privilege isn't supported" do
         Process::GID.stubs(:change_privilege).raises(NotImplementedError)
 
         Puppet::Util::SUIDManager.change_group(42, true)
 
         xids[:egid].should == 42
         xids[:gid].should == 42
       end
     end
 
     describe "when changing temporarily" do
       it "should change only egid" do
         Puppet::Util::SUIDManager.change_group(42, false)
 
         xids[:egid].should == 42
         xids[:gid].should == 0
       end
     end
   end
 
   describe "#change_user" do
     describe "when changing permanently" do
       it "should try to change_privilege if it is supported" do
         Process::UID.expects(:change_privilege).with do |uid|
           Process.uid = uid
           Process.euid = uid
         end
 
         Puppet::Util::SUIDManager.change_user(42, true)
 
         xids[:euid].should == 42
         xids[:uid].should == 42
       end
 
       it "should change euid and uid and groups if change_privilege isn't supported" do
         Process::UID.stubs(:change_privilege).raises(NotImplementedError)
 
         Puppet::Util::SUIDManager.expects(:initgroups).with(42)
 
         Puppet::Util::SUIDManager.change_user(42, true)
 
         xids[:euid].should == 42
         xids[:uid].should == 42
       end
     end
 
     describe "when changing temporarily" do
       it "should change only euid and groups" do
         Puppet::Util::SUIDManager.change_user(42, false)
 
         xids[:euid].should == 42
         xids[:uid].should == 0
       end
 
       it "should set euid before groups if changing to root" do
         Process.stubs(:euid).returns 50
 
         when_not_root = sequence 'when_not_root'
 
         Process.expects(:euid=).in_sequence(when_not_root)
         Puppet::Util::SUIDManager.expects(:initgroups).in_sequence(when_not_root)
 
         Puppet::Util::SUIDManager.change_user(0, false)
       end
 
       it "should set groups before euid if changing from root" do
         Process.stubs(:euid).returns 0
 
         when_root = sequence 'when_root'
 
         Puppet::Util::SUIDManager.expects(:initgroups).in_sequence(when_root)
         Process.expects(:euid=).in_sequence(when_root)
 
         Puppet::Util::SUIDManager.change_user(50, false)
       end
     end
   end
 
   describe "when running commands" do
     before :each do
       # We want to make sure $CHILD_STATUS is set
       Kernel.system '' if $CHILD_STATUS.nil?
     end
 
     describe "with #system" do
       it "should set euid/egid when root" do
         Process.stubs(:uid).returns(0)
+        Puppet.features.stubs(:microsoft_windows?).returns(false)
+
         Process.stubs(:egid).returns(51)
         Process.stubs(:euid).returns(50)
 
         Puppet::Util::SUIDManager.stubs(:convert_xid).with(:gid, 51).returns(51)
         Puppet::Util::SUIDManager.stubs(:convert_xid).with(:uid, 50).returns(50)
 
         Puppet::Util::SUIDManager.expects(:change_group).with(user[:uid])
         Puppet::Util::SUIDManager.expects(:change_user).with(user[:uid])
 
         Puppet::Util::SUIDManager.expects(:change_group).with(51)
         Puppet::Util::SUIDManager.expects(:change_user).with(50)
 
         Kernel.expects(:system).with('blah')
         Puppet::Util::SUIDManager.system('blah', user[:uid], user[:gid])
       end
 
       it "should not get or set euid/egid when not root" do
         Process.stubs(:uid).returns(1)
         Kernel.expects(:system).with('blah')
 
         Puppet::Util::SUIDManager.system('blah', user[:uid], user[:gid])
 
         xids.should be_empty
       end
     end
 
     describe "with #run_and_capture" do
       it "should capture the output and return process status" do
         Puppet::Util.
           expects(:execute).
           with('yay', :combine => true, :failonfail => false, :uid => user[:uid], :gid => user[:gid]).
           returns('output')
         output = Puppet::Util::SUIDManager.run_and_capture 'yay', user[:uid], user[:gid]
 
         output.first.should == 'output'
         output.last.should be_a(Process::Status)
       end
     end
   end
 end