diff --git a/spec/integration/application/doc_spec.rb b/spec/integration/application/doc_spec.rb
index 9412976f0..47fd93a03 100755
--- a/spec/integration/application/doc_spec.rb
+++ b/spec/integration/application/doc_spec.rb
@@ -1,54 +1,54 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet_spec/files'
 
 describe Puppet::Application::Doc do
   include PuppetSpec::Files
 
-  it "should not generate an error when module dir overlaps parent of site.pp (#4798)", :'fails_on_ruby_1.9.2' => true do
+  it "should not generate an error when module dir overlaps parent of site.pp (#4798)", :'fails_on_ruby_1.9.2' => true, :fails_on_windows => true do
     begin
       # Note: the directory structure below is more complex than it
       # needs to be, but it's representative of the directory structure
       # used in bug #4798.
       old_dir = Dir.getwd # Note: can't use chdir with a block because it will generate bogus warnings
       tmpdir = tmpfile('doc_spec')
       Dir.mkdir(tmpdir)
       Dir.chdir(tmpdir)
       site_file = 'site.pp'
       File.open(site_file, 'w') do |f|
         f.puts '# A comment'
       end
       modules_dir = 'modules'
       Dir.mkdir(modules_dir)
       rt_dir = File.join(modules_dir, 'rt')
       Dir.mkdir(rt_dir)
       manifests_dir = File.join(rt_dir, 'manifests')
       Dir.mkdir(manifests_dir)
       rt_file = File.join(manifests_dir, 'rt.pp')
       File.open(rt_file, 'w') do |f|
         f.puts '# A class'
         f.puts 'class foo { }'
         f.puts '# A definition'
         f.puts 'define bar { }'
       end
 
       puppet = Puppet::Application[:doc]
       Puppet[:modulepath] = modules_dir
       Puppet[:manifest] = site_file
       puppet.options[:mode] = :rdoc
 
       expect { puppet.run_command }.to exit_with 0
 
       File.should be_exist('doc')
     ensure
       Dir.chdir(old_dir)
     end
   end
 
   it "should respect the -o option" do
     puppetdoc = Puppet::Application[:doc]
     puppetdoc.command_line.stubs(:args).returns(['foo', '-o', 'bar'])
     puppetdoc.parse_options
     puppetdoc.options[:outputdir].should == 'bar'
   end
 end
diff --git a/spec/integration/file_serving/terminus_helper_spec.rb b/spec/integration/file_serving/terminus_helper_spec.rb
index 7500b1fc0..99fee9ce5 100755
--- a/spec/integration/file_serving/terminus_helper_spec.rb
+++ b/spec/integration/file_serving/terminus_helper_spec.rb
@@ -1,21 +1,21 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/terminus_helper'
 
 class TerminusHelperIntegrationTester
   include Puppet::FileServing::TerminusHelper
   def model
     Puppet::FileServing::Metadata
   end
 end
 
-describe Puppet::FileServing::TerminusHelper do
+describe Puppet::FileServing::TerminusHelper, :fails_on_windows => true do
   it "should be able to recurse on a single file" do
     @path = Tempfile.new("fileset_integration")
     request = Puppet::Indirector::Request.new(:metadata, :find, @path.path, :recurse => true)
 
     tester = TerminusHelperIntegrationTester.new
     lambda { tester.path2instances(request, @path.path) }.should_not raise_error
   end
 end
diff --git a/spec/integration/indirector/direct_file_server_spec.rb b/spec/integration/indirector/direct_file_server_spec.rb
index 15223374b..79afe7569 100755
--- a/spec/integration/indirector/direct_file_server_spec.rb
+++ b/spec/integration/indirector/direct_file_server_spec.rb
@@ -1,71 +1,71 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/file'
 
 describe Puppet::Indirector::DirectFileServer, " when interacting with the filesystem and the model", :fails_on_windows => true do
   include PuppetSpec::Files
 
   before do
     # We just test a subclass, since it's close enough.
     @terminus = Puppet::Indirector::FileContent::File.new
 
     @filepath = make_absolute("/path/to/my/file")
   end
 
   it "should return an instance of the model" do
     FileTest.expects(:exists?).with(@filepath).returns(true)
 
     @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}")).should be_instance_of(Puppet::FileServing::Content)
   end
 
   it "should return an instance capable of returning its content" do
     FileTest.expects(:exists?).with(@filepath).returns(true)
     File.stubs(:lstat).with(@filepath).returns(stub("stat", :ftype => "file"))
     File.expects(:read).with(@filepath).returns("my content")
 
     instance = @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}"))
 
     instance.content.should == "my content"
   end
 end
 
-describe Puppet::Indirector::DirectFileServer, " when interacting with FileServing::Fileset and the model" do
+describe Puppet::Indirector::DirectFileServer, " when interacting with FileServing::Fileset and the model", :fails_on_windows => true do
   before do
     @terminus = Puppet::Indirector::FileContent::File.new
 
     @path = Tempfile.new("direct_file_server_testing")
     path = @path.path
     @path.close!
     @path = path
 
     Dir.mkdir(@path)
     File.open(File.join(@path, "one"), "w") { |f| f.print "one content" }
     File.open(File.join(@path, "two"), "w") { |f| f.print "two content" }
 
     @request = @terminus.indirection.request(:search, "file:///#{@path}", :recurse => true)
   end
 
   after do
     system("rm -rf #{@path}")
   end
 
   it "should return an instance for every file in the fileset" do
     result = @terminus.search(@request)
     result.should be_instance_of(Array)
     result.length.should == 3
     result.each { |r| r.should be_instance_of(Puppet::FileServing::Content) }
   end
 
   it "should return instances capable of returning their content" do
     @terminus.search(@request).each do |instance|
       case instance.full_path
       when /one/; instance.content.should == "one content"
       when /two/; instance.content.should == "two content"
       when @path
       else
         raise "No valid key for #{instance.path.inspect}"
       end
     end
   end
 end
diff --git a/spec/integration/indirector/file_content/file_server_spec.rb b/spec/integration/indirector/file_content/file_server_spec.rb
index 787f1562d..c068d76d5 100755
--- a/spec/integration/indirector/file_content/file_server_spec.rb
+++ b/spec/integration/indirector/file_content/file_server_spec.rb
@@ -1,90 +1,90 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/file_server'
 require 'shared_behaviours/file_server_terminus'
 
 require 'puppet_spec/files'
 
-describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
+describe Puppet::Indirector::FileContent::FileServer, " when finding files", :fails_on_windows => true do
   it_should_behave_like "Puppet::Indirector::FileServerTerminus"
   include PuppetSpec::Files
 
   before do
     @terminus = Puppet::Indirector::FileContent::FileServer.new
     @test_class = Puppet::FileServing::Content
   end
 
   it "should find plugin file content in the environment specified in the request" do
     path = tmpfile("file_content_with_env")
 
     Dir.mkdir(path)
 
     modpath = File.join(path, "mod")
     FileUtils.mkdir_p(File.join(modpath, "lib"))
     file = File.join(modpath, "lib", "file.rb")
     File.open(file, "w") { |f| f.puts "1" }
 
     Puppet.settings[:modulepath] = "/no/such/file"
 
     env = Puppet::Node::Environment.new("foo")
     env.stubs(:modulepath).returns [path]
 
     result = Puppet::FileServing::Content.indirection.search("plugins", :environment => "foo", :recurse => true)
 
     result.should_not be_nil
     result.length.should == 2
     result[1].should be_instance_of(Puppet::FileServing::Content)
     result[1].content.should == "1\n"
   end
 
   it "should find file content in modules" do
     path = tmpfile("file_content")
 
     Dir.mkdir(path)
 
     modpath = File.join(path, "mymod")
     FileUtils.mkdir_p(File.join(modpath, "files"))
     file = File.join(modpath, "files", "myfile")
     File.open(file, "w") { |f| f.puts "1" }
 
     Puppet.settings[:modulepath] = path
 
     result = Puppet::FileServing::Content.indirection.find("modules/mymod/myfile")
 
     result.should_not be_nil
     result.should be_instance_of(Puppet::FileServing::Content)
     result.content.should == "1\n"
   end
 
   it "should find file content in files when node name expansions are used" do
     Puppet::Util::Cacher.expire
     FileTest.stubs(:exists?).returns true
     FileTest.stubs(:exists?).with(Puppet[:fileserverconfig]).returns(true)
 
     @path = tmpfile("file_server_testing")
 
     Dir.mkdir(@path)
     subdir = File.join(@path, "mynode")
     Dir.mkdir(subdir)
     File.open(File.join(subdir, "myfile"), "w") { |f| f.puts "1" }
 
     # Use a real mount, so the integration is a bit deeper.
     @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
     @mount1.stubs(:allowed?).returns true
     @mount1.path = File.join(@path, "%h")
 
     @parser = stub 'parser', :changed? => false
     @parser.stubs(:parse).returns("one" => @mount1)
 
     Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
 
     path = File.join(@path, "myfile")
 
     result = Puppet::FileServing::Content.indirection.find("one/myfile", :environment => "foo", :node => "mynode")
 
     result.should_not be_nil
     result.should be_instance_of(Puppet::FileServing::Content)
     result.content.should == "1\n"
   end
 end
diff --git a/spec/integration/indirector/file_metadata/file_server_spec.rb b/spec/integration/indirector/file_metadata/file_server_spec.rb
index c2cbcfa5c..2e7c54b70 100755
--- a/spec/integration/indirector/file_metadata/file_server_spec.rb
+++ b/spec/integration/indirector/file_metadata/file_server_spec.rb
@@ -1,14 +1,14 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/file_metadata/file_server'
 require 'shared_behaviours/file_server_terminus'
 
-describe Puppet::Indirector::FileMetadata::FileServer, " when finding files" do
+describe Puppet::Indirector::FileMetadata::FileServer, " when finding files", :fails_on_windows => true do
   it_should_behave_like "Puppet::Indirector::FileServerTerminus"
 
   before do
     @terminus = Puppet::Indirector::FileMetadata::FileServer.new
     @test_class = Puppet::FileServing::Metadata
   end
 end
diff --git a/spec/integration/parser/compiler_spec.rb b/spec/integration/parser/compiler_spec.rb
index 9f6aae907..51611f888 100755
--- a/spec/integration/parser/compiler_spec.rb
+++ b/spec/integration/parser/compiler_spec.rb
@@ -1,133 +1,133 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser::Compiler do
   before :each do
     @node = Puppet::Node.new "testnode"
 
     @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
     @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
   end
 
   after do
     Puppet.settings.clear
   end
 
-  it "should be able to determine the configuration version from a local version control repository" do
+  it "should be able to determine the configuration version from a local version control repository", :fails_on_windows => true do
     # This should always work, because we should always be
     # in the puppet repo when we run this.
     version = %x{git rev-parse HEAD}.chomp
 
     Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
     @parser = Puppet::Parser::Parser.new "development"
     @compiler = Puppet::Parser::Compiler.new(@node)
 
     @compiler.catalog.version.should == version
   end
 
   it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
     Puppet[:code] = <<-PP
       class foo
       {
         notify { foo_notify: }
         include bar
       }
       class bar
       {
         notify { bar_notify: }
       }
     PP
 
     @node.stubs(:classes).returns(['foo', 'bar'])
 
     catalog = Puppet::Parser::Compiler.compile(@node)
 
     catalog.resource("Notify[foo_notify]").should_not be_nil
     catalog.resource("Notify[bar_notify]").should_not be_nil
   end
 
   describe "when resolving class references" do
     it "should favor local scope, even if there's an included class in topscope" do
       Puppet[:code] = <<-PP
         class experiment {
           class baz {
           }
           notify {"x" : require => Class[Baz] }
         }
         class baz {
         }
         include baz
         include experiment
         include experiment::baz
       PP
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       notify_resource = catalog.resource( "Notify[x]" )
 
       notify_resource[:require].title.should == "Experiment::Baz"
     end
 
     it "should favor local scope, even if there's an unincluded class in topscope" do
       Puppet[:code] = <<-PP
         class experiment {
           class baz {
           }
           notify {"x" : require => Class[Baz] }
         }
         class baz {
         }
         include experiment
         include experiment::baz
       PP
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       notify_resource = catalog.resource( "Notify[x]" )
 
       notify_resource[:require].title.should == "Experiment::Baz"
     end
   end
 
   it "should recompute the version after input files are re-parsed" do
     Puppet[:code] = 'class foo { }'
     Time.stubs(:now).returns(1)
     node = Puppet::Node.new('mynode')
     Puppet::Parser::Compiler.compile(node).version.should == 1
     Time.stubs(:now).returns(2)
     Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
     Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
     Puppet::Parser::Compiler.compile(node).version.should == 2
   end
 
   ['class', 'define', 'node'].each do |thing|
     it "should not allow #{thing} inside evaluated conditional constructs" do
       Puppet[:code] = <<-PP
         if true {
           #{thing} foo {
           }
           notify { decoy: }
         }
       PP
 
       begin
         Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
         raise "compilation should have raised Puppet::Error"
       rescue Puppet::Error => e
         e.message.should =~ /at line 2/
       end
     end
   end
 
   it "should not allow classes inside unevaluated conditional constructs" do
     Puppet[:code] = <<-PP
       if false {
         class foo {
         }
       }
     PP
 
     lambda { Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode")) }.should raise_error(Puppet::Error)
   end
 end
diff --git a/spec/integration/parser/ruby_manifest_spec.rb b/spec/integration/parser/ruby_manifest_spec.rb
index 7f3bb71e9..b04baf5e0 100755
--- a/spec/integration/parser/ruby_manifest_spec.rb
+++ b/spec/integration/parser/ruby_manifest_spec.rb
@@ -1,127 +1,127 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'tempfile'
 require 'puppet_spec/files'
 
-describe "Pure ruby manifests" do
+describe "Pure ruby manifests", :fails_on_windows => true do
   include PuppetSpec::Files
 
   before do
     @node = Puppet::Node.new "testnode"
 
     @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
     @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
     @test_dir = tmpdir('ruby_manifest_test')
   end
 
   after do
     Puppet.settings.clear
   end
 
   def write_file(name, contents)
     path = File.join(@test_dir, name)
     File.open(path, "w") { |f| f.write(contents) }
     path
   end
 
   def compile(contents)
     Puppet[:code] = contents
     Dir.chdir(@test_dir) do
       Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
     end
   end
 
   it "should allow classes" do
     write_file('foo.rb', ["hostclass 'one' do notify('one_notify') end",
                           "hostclass 'two' do notify('two_notify') end"].join("\n"))
     catalog = compile("import 'foo'\ninclude one")
     catalog.resource("Notify[one_notify]").should_not be_nil
     catalog.resource("Notify[two_notify]").should be_nil
   end
 
   it "should allow defines" do
     write_file('foo.rb', 'define "bar", :arg do notify("bar_#{@name}_#{@arg}") end')
     catalog = compile("import 'foo'\nbar { instance: arg => 'xyz' }")
     catalog.resource("Notify[bar_instance_xyz]").should_not be_nil
     catalog.resource("Bar[instance]").should_not be_nil
   end
 
   it "should allow node declarations" do
     write_file('foo.rb', "node 'mynode' do notify('mynode') end")
     catalog = compile("import 'foo'")
     node_declaration = catalog.resource("Notify[mynode]")
     node_declaration.should_not be_nil
     node_declaration.title.should == 'mynode'
   end
 
   it "should allow access to the environment" do
     write_file('foo.rb', ["hostclass 'bar' do",
                           "  if environment.is_a? Puppet::Node::Environment",
                           "    notify('success')",
                           "  end",
                           "end"].join("\n"))
     compile("import 'foo'\ninclude bar").resource("Notify[success]").should_not be_nil
   end
 
   it "should allow creation of resources of built-in types" do
     write_file('foo.rb', "hostclass 'bar' do file 'test_file', :owner => 'root', :mode => '644' end")
     catalog = compile("import 'foo'\ninclude bar")
     file = catalog.resource("File[test_file]")
     file.should be_a(Puppet::Resource)
     file.type.should == 'File'
     file.title.should == 'test_file'
     file.exported.should_not be
     file.virtual.should_not be
     file[:owner].should == 'root'
     file[:mode].should == '644'
     file[:stage].should be_nil # TODO: is this correct behavior?
   end
 
   it "should allow calling user-defined functions" do
     write_file('foo.rb', "hostclass 'bar' do user_func 'name', :arg => 'xyz' end")
     catalog = compile(['define user_func($arg) { notify {"n_$arg": } }',
                        'import "foo"',
                        'include bar'].join("\n"))
     catalog.resource("Notify[n_xyz]").should_not be_nil
     catalog.resource("User_func[name]").should_not be_nil
   end
 
   it "should be properly cached for multiple compiles" do
     # Note: we can't test this by calling compile() twice, because
     # that sets Puppet[:code], which clears out all cached
     # environments.
     Puppet[:filetimeout] = 1000
     write_file('foo.rb', "hostclass 'bar' do notify('success') end")
     Puppet[:code] = "import 'foo'\ninclude bar"
 
     # Compile the catalog and check it
     catalog = Dir.chdir(@test_dir) do
       Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
     end
     catalog.resource("Notify[success]").should_not be_nil
 
     # Secretly change the file to make it invalid.  This change
     # shouldn't be noticed because the we've set a high
     # Puppet[:filetimeout].
     write_file('foo.rb', "raise 'should not be executed'")
 
     # Compile the catalog a second time and make sure it's still ok.
     catalog = Dir.chdir(@test_dir) do
       Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
     end
     catalog.resource("Notify[success]").should_not be_nil
   end
 
   it "should be properly reloaded when stale" do
     Puppet[:filetimeout] = -1 # force stale check to happen all the time
     write_file('foo.rb', "hostclass 'bar' do notify('version1') end")
     catalog = compile("import 'foo'\ninclude bar")
     catalog.resource("Notify[version1]").should_not be_nil
     sleep 1 # so that timestamp will change forcing file reload
     write_file('foo.rb', "hostclass 'bar' do notify('version2') end")
     catalog = compile("import 'foo'\ninclude bar")
     catalog.resource("Notify[version1]").should be_nil
     catalog.resource("Notify[version2]").should_not be_nil
   end
 end
diff --git a/spec/integration/provider/mount_spec.rb b/spec/integration/provider/mount_spec.rb
index 4af0dca4a..eb8cc134a 100755
--- a/spec/integration/provider/mount_spec.rb
+++ b/spec/integration/provider/mount_spec.rb
@@ -1,151 +1,151 @@
 require 'spec_helper'
 
 require 'puppet/file_bucket/dipper'
 
-describe "mount provider (integration)" do
+describe "mount provider (integration)", :fails_on_windows => true do
   include PuppetSpec::Files
 
   def create_fake_fstab(initially_contains_entry)
     File.open(@fake_fstab, 'w') do |f|
       if initially_contains_entry
         f.puts("/dev/disk1s1\t/Volumes/foo_disk\tmsdos\tlocal\t0\t0")
       end
     end
   end
 
   before :each do
     @fake_fstab = tmpfile('fstab')
     @current_options = "local"
     @current_device = "/dev/disk1s1"
     Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
     Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
     Puppet::Util::ExecutionStub.set do |command, options|
       case command[0]
       when %r{/s?bin/mount}
         if command.length == 1
           if @mounted
             "#{@current_device} on /Volumes/foo_disk (msdos, #{@current_options})\n"
           else
             ''
           end
         else
           command.length.should == 4
           command[1].should == '-o'
           command[3].should == '/Volumes/foo_disk'
           @mounted.should == false # verify that we don't try to call "mount" redundantly
           @current_options = command[2]
           @current_device = check_fstab(true)
           @mounted = true
           ''
         end
       when %r{/s?bin/umount}
         command.length.should == 2
         command[1].should == '/Volumes/foo_disk'
         @mounted.should == true # "umount" doesn't work when device not mounted (see #6632)
         @mounted = false
         ''
       else
         fail "Unexpected command #{command.inspect} executed"
       end
     end
   end
 
   after :each do
     Puppet::Type::Mount::ProviderParsed.clear # Work around bug #6628
   end
 
   def check_fstab(expected_to_be_present)
     # Verify that the fake fstab has the expected data in it
     fstab_contents = File.read(@fake_fstab).split("\n").reject { |x| x =~ /^#|^$/ }
     if expected_to_be_present
       fstab_contents.length().should == 1
       device, rest_of_line = fstab_contents[0].split(/\t/,2)
       rest_of_line.should == "/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0"
       device
     else
       fstab_contents.length().should == 0
       nil
     end
   end
 
   def run_in_catalog(settings)
     resource = Puppet::Type.type(:mount).new(settings.merge(:name => "/Volumes/foo_disk",
                                              :device => "/dev/disk1s1", :fstype => "msdos"))
     Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
     resource.expects(:err).never
     catalog = Puppet::Resource::Catalog.new
     catalog.host_config = false # Stop Puppet from doing a bunch of magic
     catalog.add_resource resource
     catalog.apply
   end
 
   [false, true].each do |initial_state|
     describe "When initially #{initial_state ? 'mounted' : 'unmounted'}" do
       before :each do
         @mounted = initial_state
       end
 
       [false, true].each do |initial_fstab_entry|
         describe "When there is #{initial_fstab_entry ? 'an' : 'no'} initial fstab entry" do
           before :each do
             create_fake_fstab(initial_fstab_entry)
           end
 
           [:defined, :present, :mounted, :unmounted, :absent].each do |ensure_setting|
             expected_final_state = case ensure_setting
               when :mounted
                 true
               when :unmounted, :absent
                 false
               when :defined, :present
                 initial_state
               else
                 fail "Unknown ensure_setting #{ensure_setting}"
             end
             expected_fstab_data = (ensure_setting != :absent)
             describe "When setting ensure => #{ensure_setting}" do
               ["local", "journaled"].each do |options_setting|
                 describe "When setting options => #{options_setting}" do
                   it "should leave the system in the #{expected_final_state ? 'mounted' : 'unmounted'} state, #{expected_fstab_data ? 'with' : 'without'} data in /etc/fstab" do
                     @desired_options = options_setting
                     run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
                     @mounted.should == expected_final_state
                     if expected_fstab_data
                       check_fstab(expected_fstab_data).should == "/dev/disk1s1"
                     else
                       check_fstab(expected_fstab_data).should == nil
                     end
                     if @mounted
                       if ![:defined, :present].include?(ensure_setting)
                         @current_options.should == @desired_options
                       elsif initial_fstab_entry
                         @current_options.should == @desired_options
                       else
                         @current_options.should == 'local' #Workaround for #6645
                       end
                     end
                   end
                 end
               end
             end
           end
         end
       end
     end
   end
 
   describe "When the wrong device is mounted" do
     it "should remount the correct device" do
       pending "Due to bug 6309"
       @mounted = true
       @current_device = "/dev/disk2s2"
       create_fake_fstab(true)
       @desired_options = "local"
       run_in_catalog(:ensure=>:mounted, :options=>'local')
       @current_device.should=="/dev/disk1s1"
       @mounted.should==true
       @current_options.should=='local'
       check_fstab(true).should == "/dev/disk1s1"
     end
   end
 end
diff --git a/spec/integration/provider/package_spec.rb b/spec/integration/provider/package_spec.rb
index 5fecdf13c..701752371 100755
--- a/spec/integration/provider/package_spec.rb
+++ b/spec/integration/provider/package_spec.rb
@@ -1,23 +1,23 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "Package Provider", :'fails_on_ruby_1.9.2' => true do
   Puppet::Type.type(:package).providers.each do |name|
     provider = Puppet::Type.type(:package).provider(name)
 
     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
+      it "should be able to get a list of existing packages", :fails_on_windows => true 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/ssh_authorized_key_spec.rb b/spec/integration/provider/ssh_authorized_key_spec.rb
old mode 100644
new mode 100755
index 902f9ad22..f7f61ab25
--- a/spec/integration/provider/ssh_authorized_key_spec.rb
+++ b/spec/integration/provider/ssh_authorized_key_spec.rb
@@ -1,207 +1,207 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 require 'puppet/file_bucket/dipper'
 
-describe "ssh_authorized_key provider (integration)" do
+describe "ssh_authorized_key provider (integration)", :fails_on_windows => true do
   include PuppetSpec::Files
 
   before :each do
     @fake_userfile = tmpfile('authorized_keys.user')
     @fake_rootfile = tmpfile('authorized_keys.root')
 
     # few testkeys generated with ssh-keygen
     @sample_rsa_keys = [
       'AAAAB3NzaC1yc2EAAAADAQABAAAAgQCi18JBZOq10X3w4f67nVhO0O3s5Y1vHH4UgMSM3ZnQwbC5hjGyYSi9UULOoQQoQynI/a0I9NL423/Xk/XJVIKCHcS8q6V2Wmjd+fLNelOjxxoW6mbIytEt9rDvwgq3Mof3/m21L3t2byvegR00a+ikKbmInPmKwjeWZpexCIsHzQ==', # 1024 bit
       'AAAAB3NzaC1yc2EAAAADAQABAAAAgQDLClyvi3CsJw5Id6khZs2/+s11qOH4Gdp6iDioDsrIp0m8kSiPr71VGyQYAfPzzvHemHS7Xg0NkG1Kc8u9tRqBQfTvz7ubq0AT/g01+4P2hQ/soFkuwlUG/HVnnaYb6N0Qp5SHWvD5vBE2nFFQVpP5GrSctPtHSjzJq/i+6LYhmQ==', # 1024 bit
       'AAAAB3NzaC1yc2EAAAADAQABAAABAQDLygAO6txXkh9FNV8xSsBkATeqLbHzS7sFjGI3gt0Dx6q3LjyKwbhQ1RLf28kd5G6VWiXmClU/RtiPdUz8nrGuun++2mrxzrXrvpR9dq1lygLQ2wn2cI35dN5bjRMtXy3decs6HUhFo9MoNwX250rUWfdCyNPhGIp6OOfmjdy+UeLGNxq9wDx6i4bT5tVVSqVRtsEfw9+ICXchzl85QudjneVVpP+thriPZXfXA5eaGwAo/dmoKOIhUwF96gpdLqzNtrGQuxPbV80PTbGv9ZtAtTictxaDz8muXO7he9pXmchUpxUKtMFjHkL0FAZ9tRPmv3RA30sEr2fZ8+LKvnE50w0' #2048 Bit
     ]
     @sample_dsa_keys = [
       'AAAAB3NzaC1kc3MAAACBAOPck2O8MIDSqxPSnvENt6tzRrKJ5oOhB6Nc6oEcWm+VEH1gvuxdiRqwoMgRwyEf1yUd+UAcLw3a6Jn+EtFyEBN/5WF+4Tt4xTxZ0Pfik2Wc5uqHbQ2dkmOoXiAOYPiD3JUQ1Xwm/J0CgetjitoLfzAGdCNhMqguqAuHcVJ78ZZbAAAAFQCIBKFYZ+I18I+dtgteirXh+VVEEwAAAIEAs1yvQ/wnLLrRCM660pF4kBiw3D6dJfMdCXWQpn0hZmkBQSIzZv4Wuk3giei5luxscDxNc+y3CTXtnyG4Kt1Yi2sOdvhRI3rX8tD+ejn8GHazM05l5VIo9uu4AQPIE32iV63IqgApSBbJ6vDJW91oDH0J492WdLCar4BS/KE3cRwAAACBAN0uSDyJqYLRsfYcFn4HyVf6TJxQm1IcwEt6GcJVzgjri9VtW7FqY5iBqa9B9Zdh5XXAYJ0XLsWQCcrmMHM2XGHGpA4gL9VlCJ/0QvOcXxD2uK7IXwAVUA7g4V4bw8EVnFv2Flufozhsp+4soo1xiYc5jiFVHwVlk21sMhAtKAeF' # 1024 Bit
     ]
 
     @sample_lines = [
       "ssh-rsa #{@sample_rsa_keys[1]} root@someotherhost",
       "ssh-dss #{@sample_dsa_keys[0]} root@anywhere",
       "ssh-rsa #{@sample_rsa_keys[2]} paul"
     ]
 
   end
 
   after :each do
     Puppet::Type::Ssh_authorized_key::ProviderParsed.clear # Work around bug #6628
   end
 
   def create_fake_key(username, content)
     filename = (username == :root ? @fake_rootfile : @fake_userfile )
     File.open(filename, 'w') do |f|
       content.each do |line|
         f.puts line
       end
     end
   end
 
   def check_fake_key(username, expected_content)
     filename = (username == :root ? @fake_rootfile : @fake_userfile )
     content = File.readlines(filename).map(&:chomp).sort.reject{ |x| x =~ /^#|^$/ }
     content.join("\n").should == expected_content.sort.join("\n")
   end
 
   def run_in_catalog(*resources)
     Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
     catalog = Puppet::Resource::Catalog.new
     catalog.host_config = false
     resources.each do |resource|
       resource.expects(:err).never
       catalog.add_resource(resource)
     end
     catalog.apply
   end
 
   describe "when managing one resource" do
 
     before :each do
       # We are not running as root so chown/chmod is not possible
       File.stubs(:chown)
       File.stubs(:chmod)
       Puppet::Util::SUIDManager.stubs(:asuser).yields
     end
 
     describe "with ensure set to absent" do
 
       before :each do
         @example = Puppet::Type.type(:ssh_authorized_key).new(
           :name     => 'root@hostname',
           :type     => :rsa,
           :key      => @sample_rsa_keys[0],
           :target   => @fake_rootfile,
           :user     => 'root',
           :ensure   => :absent
         )
       end
 
       it "should not modify root's keyfile if resource is currently not present" do
         create_fake_key(:root, @sample_lines)
         run_in_catalog(@example)
         check_fake_key(:root, @sample_lines)
       end
 
       it "remove the key from root's keyfile if resource is currently present" do
         create_fake_key(:root, @sample_lines + ["ssh-rsa #{@sample_rsa_keys[0]} root@hostname"])
         run_in_catalog(@example)
         check_fake_key(:root, @sample_lines)
       end
 
     end
 
     describe "when ensure is present" do
 
       before :each do
         @example = Puppet::Type.type(:ssh_authorized_key).new(
           :name     => 'root@hostname',
           :type     => :rsa,
           :key      => @sample_rsa_keys[0],
           :target   => @fake_rootfile,
           :user     => 'root',
           :ensure   => :present
         )
 
         # just a dummy so the parsedfile provider is aware
         # of the user's authorized_keys file
         @dummy = Puppet::Type.type(:ssh_authorized_key).new(
           :name   => 'dummy',
           :target => @fake_userfile,
           :user   => 'nobody',
           :ensure => :absent
         )
       end
 
       it "should add the key if it is not present" do
         create_fake_key(:root, @sample_lines)
         run_in_catalog(@example)
         check_fake_key(:root, @sample_lines + ["ssh-rsa #{@sample_rsa_keys[0]} root@hostname" ])
       end
 
       it "should modify the type if type is out of sync" do
         create_fake_key(:root,@sample_lines + [ "ssh-dss #{@sample_rsa_keys[0]} root@hostname" ])
         run_in_catalog(@example)
         check_fake_key(:root, @sample_lines + [ "ssh-rsa #{@sample_rsa_keys[0]} root@hostname" ])
       end
 
       it "should modify the key if key is out of sync" do
         create_fake_key(:root,@sample_lines + [ "ssh-rsa #{@sample_rsa_keys[1]} root@hostname" ])
         run_in_catalog(@example)
         check_fake_key(:root, @sample_lines + [ "ssh-rsa #{@sample_rsa_keys[0]} root@hostname" ])
       end
 
       it "should remove the key from old file if target is out of sync" do
         create_fake_key(:user, [ @sample_lines[0], "ssh-rsa #{@sample_rsa_keys[0]} root@hostname" ])
         create_fake_key(:root, [ @sample_lines[1], @sample_lines[2] ])
         run_in_catalog(@example, @dummy)
         check_fake_key(:user, [ @sample_lines[0] ])
         #check_fake_key(:root, [ @sample_lines[1], @sample_lines[2], "ssh-rsa #{@sample_rsa_keys[0]} root@hostname" ])
       end
 
       it "should add the key to new file if target is out of sync" do
         create_fake_key(:user, [ @sample_lines[0], "ssh-rsa #{@sample_rsa_keys[0]} root@hostname" ])
         create_fake_key(:root, [ @sample_lines[1], @sample_lines[2] ])
         run_in_catalog(@example, @dummy)
         #check_fake_key(:user, [ @sample_lines[0] ])
         check_fake_key(:root, [ @sample_lines[1], @sample_lines[2], "ssh-rsa #{@sample_rsa_keys[0]} root@hostname" ])
       end
 
       it "should modify options if options are out of sync" do
         @example[:options]=[ 'from="correct.domain.com"', 'no-port-forwarding', 'no-pty' ]
         create_fake_key(:root, @sample_lines + [ "from=\"incorrect.domain.com\",no-port-forwarding,no-pty ssh-rsa #{@sample_rsa_keys[0]} root@hostname"])
         run_in_catalog(@example)
         check_fake_key(:root, @sample_lines + [ "from=\"correct.domain.com\",no-port-forwarding,no-pty ssh-rsa #{@sample_rsa_keys[0]} root@hostname"] )
       end
 
     end
 
   end
 
   describe "when managing two resource" do
 
       before :each do
         # We are not running as root so chown/chmod is not possible
         File.stubs(:chown)
         File.stubs(:chmod)
         Puppet::Util::SUIDManager.stubs(:asuser).yields
         @example_one = Puppet::Type.type(:ssh_authorized_key).new(
           :name     => 'root@hostname',
           :type     => :rsa,
           :key      => @sample_rsa_keys[0],
           :target   => @fake_rootfile,
           :user     => 'root',
           :ensure   => :present
         )
 
         @example_two = Puppet::Type.type(:ssh_authorized_key).new(
           :name   => 'user@hostname',
           :key    => @sample_rsa_keys[1],
           :type   => :rsa,
           :target => @fake_userfile,
           :user   => 'nobody',
           :ensure => :present
         )
       end
 
     describe "and both keys are absent" do
 
       before :each do
         create_fake_key(:root, @sample_lines)
         create_fake_key(:user, @sample_lines)
       end
 
       it "should add both keys" do
         run_in_catalog(@example_one, @example_two)
         check_fake_key(:root, @sample_lines + [ "ssh-rsa #{@sample_rsa_keys[0]} root@hostname" ])
         check_fake_key(:user, @sample_lines + [ "ssh-rsa #{@sample_rsa_keys[1]} user@hostname" ])
       end
 
     end
 
   end
 
 end
diff --git a/spec/integration/resource/type_collection_spec.rb b/spec/integration/resource/type_collection_spec.rb
index 6ea2e7fe7..0852a9850 100755
--- a/spec/integration/resource/type_collection_spec.rb
+++ b/spec/integration/resource/type_collection_spec.rb
@@ -1,95 +1,95 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet_spec/files'
 require 'puppet/resource/type_collection'
 
-describe Puppet::Resource::TypeCollection do
+describe Puppet::Resource::TypeCollection, :fails_on_windows => true do
   describe "when autoloading from modules" do
     include PuppetSpec::Files
 
     before do
       @dir = tmpfile("autoload_testing")
       Puppet[:modulepath] = @dir
 
       FileUtils.mkdir_p @dir
       @code = Puppet::Resource::TypeCollection.new("env")
       Puppet::Node::Environment.new("env").stubs(:known_resource_types).returns @code
     end
 
     # Setup a module.
     def mk_module(name, files = {})
       mdir = File.join(@dir, name)
       mandir = File.join(mdir, "manifests")
       FileUtils.mkdir_p mandir
 
       defs = files.delete(:define)
 
       Dir.chdir(mandir) do
         files.each do |file, classes|
           File.open("#{file}.pp", "w") do |f|
             classes.each { |klass|
               if defs
                 f.puts "define #{klass} {}"
               else
                 f.puts "class #{klass} {}"
               end
             }
           end
         end
       end
     end
 
     it "should return nil when a class can't be found or loaded" do
       @code.find_hostclass('', 'nosuchclass').should be_nil
     end
 
     it "should load the module's init file first" do
       name = "simple"
       mk_module(name, :init => [name])
 
       @code.find_hostclass("", name).name.should == name
     end
 
     it "should load the module's init file even when searching from a different namespace" do
       name = "simple"
       mk_module(name, :init => [name])
 
       @code.find_hostclass("other::ns", name).name.should == name
     end
 
     it "should be able to load definitions from the module base file" do
       name = "simpdef"
       mk_module(name, :define => true, :init => [name])
       @code.find_definition("", name).name.should == name
     end
 
     it "should be able to load qualified classes from the module base file" do
       modname = "both"
       name = "sub"
       mk_module(modname, :init => %w{both both::sub})
 
       @code.find_hostclass("both", name).name.should == "both::sub"
     end
 
     it "should be able load classes from a separate file" do
       modname = "separate"
       name = "sub"
       mk_module(modname, :init => %w{separate}, :sub => %w{separate::sub})
       @code.find_hostclass("separate", name).name.should == "separate::sub"
     end
 
     it "should not fail when loading from a separate file if there is no module file" do
       modname = "alone"
       name = "sub"
       mk_module(modname, :sub => %w{alone::sub})
       lambda { @code.find_hostclass("alone", name) }.should_not raise_error
     end
 
     it "should be able to load definitions from their own file" do
       name = "mymod"
       mk_module(name, :define => true, :mydefine => ["mymod::mydefine"])
       @code.find_definition("", "mymod::mydefine").name.should == "mymod::mydefine"
     end
   end
 end
diff --git a/spec/integration/ssl/certificate_authority_spec.rb b/spec/integration/ssl/certificate_authority_spec.rb
index 2517f121e..af06437c4 100755
--- a/spec/integration/ssl/certificate_authority_spec.rb
+++ b/spec/integration/ssl/certificate_authority_spec.rb
@@ -1,130 +1,130 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_authority'
 require 'tempfile'
 
-describe Puppet::SSL::CertificateAuthority do
+describe Puppet::SSL::CertificateAuthority, :fails_on_windows => true do
   before do
     # Get a safe temporary file
     file = Tempfile.new("ca_integration_testing")
     @dir = file.path
     file.delete
 
     Puppet.settings[:confdir] = @dir
     Puppet.settings[:vardir] = @dir
     Puppet.settings[:group] = Process.gid
 
     Puppet::SSL::Host.ca_location = :local
     @ca = Puppet::SSL::CertificateAuthority.new
   end
 
   after {
     Puppet::SSL::Host.ca_location = :none
 
     system("rm -rf #{@dir}")
     Puppet.settings.clear
 
     Puppet::Util::Cacher.expire
 
     Puppet::SSL::CertificateAuthority.instance_variable_set("@instance", nil)
   }
 
   it "should create a CA host" do
     @ca.host.should be_ca
   end
 
   it "should be able to generate a certificate" do
     @ca.generate_ca_certificate
 
     @ca.host.certificate.should be_instance_of(Puppet::SSL::Certificate)
   end
 
   it "should be able to generate a new host certificate" do
     @ca.generate("newhost")
 
     Puppet::SSL::Certificate.indirection.find("newhost").should be_instance_of(Puppet::SSL::Certificate)
   end
 
   it "should be able to revoke a host certificate" do
     @ca.generate("newhost")
 
     @ca.revoke("newhost")
 
     lambda { @ca.verify("newhost") }.should raise_error
   end
 
   it "should have a CRL" do
     @ca.generate_ca_certificate
     @ca.crl.should_not be_nil
   end
 
   it "should be able to read in a previously created CRL" do
     @ca.generate_ca_certificate
 
     # Create it to start with.
     @ca.crl
 
     Puppet::SSL::CertificateAuthority.new.crl.should_not be_nil
   end
 
   describe "when signing certificates" do
     before do
       @host = Puppet::SSL::Host.new("luke.madstop.com")
 
       # We have to provide the key, since when we're in :ca_only mode, we can only interact
       # with the CA key.
       key = Puppet::SSL::Key.new(@host.name)
       key.generate
 
       @host.key = key
       @host.generate_certificate_request
 
       path = File.join(Puppet[:requestdir], "luke.madstop.com.pem")
     end
 
     it "should be able to sign certificates" do
       @ca.sign("luke.madstop.com")
     end
 
     it "should save the signed certificate" do
       @ca.sign("luke.madstop.com")
 
       Puppet::SSL::Certificate.indirection.find("luke.madstop.com").should be_instance_of(Puppet::SSL::Certificate)
     end
 
     it "should be able to sign multiple certificates" do
       @other = Puppet::SSL::Host.new("other.madstop.com")
       okey = Puppet::SSL::Key.new(@other.name)
       okey.generate
       @other.key = okey
       @other.generate_certificate_request
 
       @ca.sign("luke.madstop.com")
       @ca.sign("other.madstop.com")
 
       Puppet::SSL::Certificate.indirection.find("other.madstop.com").should be_instance_of(Puppet::SSL::Certificate)
       Puppet::SSL::Certificate.indirection.find("luke.madstop.com").should be_instance_of(Puppet::SSL::Certificate)
     end
 
     it "should save the signed certificate to the :signeddir" do
       @ca.sign("luke.madstop.com")
 
       client_cert = File.join(Puppet[:signeddir], "luke.madstop.com.pem")
       File.read(client_cert).should == Puppet::SSL::Certificate.indirection.find("luke.madstop.com").content.to_s
     end
 
     it "should save valid certificates" do
       @ca.sign("luke.madstop.com")
 
       unless ssl = Puppet::Util::which('openssl')
         pending "No ssl available"
       else
         ca_cert = Puppet[:cacert]
         client_cert = File.join(Puppet[:signeddir], "luke.madstop.com.pem")
         output = %x{openssl verify -CAfile #{ca_cert} #{client_cert}}
         $CHILD_STATUS.should == 0
       end
     end
   end
 end
diff --git a/spec/integration/ssl/certificate_request_spec.rb b/spec/integration/ssl/certificate_request_spec.rb
index 4f3e98dc8..9feeac698 100755
--- a/spec/integration/ssl/certificate_request_spec.rb
+++ b/spec/integration/ssl/certificate_request_spec.rb
@@ -1,58 +1,58 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_request'
 require 'tempfile'
 
-describe Puppet::SSL::CertificateRequest do
+describe Puppet::SSL::CertificateRequest, :fails_on_windows => true do
   before do
     # Get a safe temporary file
     file = Tempfile.new("csr_integration_testing")
     @dir = file.path
     file.delete
 
     Dir.mkdir(@dir)
 
     Puppet.settings.clear
 
     Puppet.settings[:confdir] = @dir
     Puppet.settings[:vardir] = @dir
     Puppet.settings[:group] = Process.gid
 
     Puppet::SSL::Host.ca_location = :none
 
     @csr = Puppet::SSL::CertificateRequest.new("luke.madstop.com")
 
     @key = OpenSSL::PKey::RSA.new(512)
   end
 
   after do
     system("rm -rf #{@dir}")
     Puppet.settings.clear
 
     # This is necessary so the terminus instances don't lie around.
     Puppet::Util::Cacher.expire
   end
 
   it "should be able to generate CSRs" do
     @csr.generate(@key)
   end
 
   it "should be able to save CSRs" do
     Puppet::SSL::CertificateRequest.indirection.save(@csr)
   end
 
   it "should be able to find saved certificate requests via the Indirector" do
     @csr.generate(@key)
     Puppet::SSL::CertificateRequest.indirection.save(@csr)
 
     Puppet::SSL::CertificateRequest.indirection.find("luke.madstop.com").should be_instance_of(Puppet::SSL::CertificateRequest)
   end
 
   it "should save the completely CSR when saving" do
     @csr.generate(@key)
     Puppet::SSL::CertificateRequest.indirection.save(@csr)
 
     Puppet::SSL::CertificateRequest.indirection.find("luke.madstop.com").content.to_s.should == @csr.content.to_s
   end
 end
diff --git a/spec/integration/ssl/certificate_revocation_list_spec.rb b/spec/integration/ssl/certificate_revocation_list_spec.rb
index 55e8f4ac7..aab609156 100755
--- a/spec/integration/ssl/certificate_revocation_list_spec.rb
+++ b/spec/integration/ssl/certificate_revocation_list_spec.rb
@@ -1,39 +1,39 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_revocation_list'
 require 'tempfile'
 
-describe Puppet::SSL::CertificateRevocationList do
+describe Puppet::SSL::CertificateRevocationList, :fails_on_windows => true do
   before do
     # Get a safe temporary file
     file = Tempfile.new("ca_integration_testing")
     @dir = file.path
     file.delete
 
     Puppet.settings[:confdir] = @dir
     Puppet.settings[:vardir] = @dir
     Puppet.settings[:group] = Process.gid
 
     Puppet::SSL::Host.ca_location = :local
   end
 
   after {
     Puppet::SSL::Host.ca_location = :none
 
     system("rm -rf #{@dir}")
     Puppet.settings.clear
 
     # This is necessary so the terminus instances don't lie around.
     Puppet::Util::Cacher.expire
   }
 
   it "should be able to read in written out CRLs with no revoked certificates" do
     ca = Puppet::SSL::CertificateAuthority.new
 
     raise "CRL not created" unless FileTest.exist?(Puppet[:hostcrl])
 
     crl = Puppet::SSL::CertificateRevocationList.new("crl_int_testing")
     crl.read(Puppet[:hostcrl])
   end
 end
diff --git a/spec/integration/ssl/host_spec.rb b/spec/integration/ssl/host_spec.rb
index 5aa3eebad..4ee32bcc7 100755
--- a/spec/integration/ssl/host_spec.rb
+++ b/spec/integration/ssl/host_spec.rb
@@ -1,87 +1,87 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/host'
 require 'tempfile'
 
-describe Puppet::SSL::Host do
+describe Puppet::SSL::Host, :fails_on_windows => true do
   before do
     # Get a safe temporary file
     file = Tempfile.new("host_integration_testing")
     @dir = file.path
     file.delete
 
     Puppet.settings[:confdir] = @dir
     Puppet.settings[:vardir] = @dir
     Puppet.settings[:group] = Process.gid
 
     Puppet::SSL::Host.ca_location = :local
 
     @host = Puppet::SSL::Host.new("luke.madstop.com")
     @ca = Puppet::SSL::CertificateAuthority.new
   end
 
   after {
     Puppet::SSL::Host.ca_location = :none
 
     system("rm -rf #{@dir}")
     Puppet.settings.clear
     Puppet::Util::Cacher.expire
   }
 
   it "should be considered a CA host if its name is equal to 'ca'" do
     Puppet::SSL::Host.new(Puppet::SSL::CA_NAME).should be_ca
   end
 
   describe "when managing its key" do
     it "should be able to generate and save a key" do
       @host.generate_key
     end
 
     it "should save the key such that the Indirector can find it" do
       @host.generate_key
 
       Puppet::SSL::Key.indirection.find(@host.name).content.to_s.should == @host.key.to_s
     end
 
     it "should save the private key into the :privatekeydir" do
       @host.generate_key
       File.read(File.join(Puppet.settings[:privatekeydir], "luke.madstop.com.pem")).should == @host.key.to_s
     end
   end
 
   describe "when managing its certificate request" do
     it "should be able to generate and save a certificate request" do
       @host.generate_certificate_request
     end
 
     it "should save the certificate request such that the Indirector can find it" do
       @host.generate_certificate_request
 
       Puppet::SSL::CertificateRequest.indirection.find(@host.name).content.to_s.should == @host.certificate_request.to_s
     end
 
     it "should save the private certificate request into the :privatekeydir" do
       @host.generate_certificate_request
       File.read(File.join(Puppet.settings[:requestdir], "luke.madstop.com.pem")).should == @host.certificate_request.to_s
     end
   end
 
   describe "when the CA host" do
     it "should never store its key in the :privatekeydir" do
       Puppet.settings.use(:main, :ssl, :ca)
       @ca = Puppet::SSL::Host.new(Puppet::SSL::Host.ca_name)
       @ca.generate_key
 
       FileTest.should_not be_exist(File.join(Puppet[:privatekeydir], "ca.pem"))
     end
   end
 
   it "should pass the verification of its own SSL store" do
     @host.generate
     @ca = Puppet::SSL::CertificateAuthority.new
     @ca.sign(@host.name)
 
     @host.ssl_store.verify(@host.certificate.content).should be_true
   end
 end
diff --git a/spec/integration/type/file_spec.rb b/spec/integration/type/file_spec.rb
index 1a328b0b2..241861cc5 100755
--- a/spec/integration/type/file_spec.rb
+++ b/spec/integration/type/file_spec.rb
@@ -1,511 +1,511 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet_spec/files'
 
 describe Puppet::Type.type(:file) do
   include PuppetSpec::Files
 
   before do
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should not attempt to manage files that do not exist if no means of creating the file is specified" do
     file = Puppet::Type.type(:file).new :path => make_absolute("/my/file"), :mode => "755"
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file
 
     file.parameter(:mode).expects(:retrieve).never
 
     transaction = Puppet::Transaction.new(catalog)
     transaction.resource_harness.evaluate(file).should_not be_failed
   end
 
   describe "when writing files" do
-    it "should backup files to a filebucket when one is configured" do
+    it "should backup files to a filebucket when one is configured", :fails_on_windows => true do
       bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = Puppet::Type.type(:file).new :path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo"
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
       catalog.add_resource bucket
 
       File.open(file[:path], "w") { |f| f.puts "bar" }
 
       md5 = Digest::MD5.hexdigest(File.read(file[:path]))
 
       catalog.apply
 
       bucket.bucket.getfile(md5).should == "bar\n"
     end
 
     it "should backup files in the local directory when a backup string is provided" do
       file = Puppet::Type.type(:file).new :path => tmpfile("bucket_backs"), :backup => ".bak", :content => "foo"
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       File.open(file[:path], "w") { |f| f.puts "bar" }
 
       catalog.apply
 
       backup = file[:path] + ".bak"
       FileTest.should be_exist(backup)
       File.read(backup).should == "bar\n"
     end
 
     it "should fail if no backup can be performed" do
       dir = tmpfile("backups")
       Dir.mkdir(dir)
       path = File.join(dir, "testfile")
       file = Puppet::Type.type(:file).new :path => path, :backup => ".bak", :content => "foo"
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       File.open(file[:path], "w") { |f| f.puts "bar" }
 
       # Create a directory where the backup should be so that writing to it fails
       Dir.mkdir(File.join(dir, "testfile.bak"))
 
       Puppet::Util::Log.stubs(:newmessage)
 
       catalog.apply
 
       File.read(file[:path]).should == "bar\n"
     end
 
-    it "should not backup symlinks" do
+    it "should not backup symlinks", :fails_on_windows => true do
       link = tmpfile("link")
       dest1 = tmpfile("dest1")
       dest2 = tmpfile("dest2")
       bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = Puppet::Type.type(:file).new :path => link, :target => dest2, :ensure => :link, :backup => "mybucket"
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
       catalog.add_resource bucket
 
       File.open(dest1, "w") { |f| f.puts "whatever" }
       File.symlink(dest1, link)
 
       md5 = Digest::MD5.hexdigest(File.read(file[:path]))
 
       catalog.apply
 
       File.readlink(link).should == dest2
       Find.find(bucket[:path]) { |f| File.file?(f) }.should be_nil
     end
 
     it "should backup directories to the local filesystem by copying the whole directory" do
       file = Puppet::Type.type(:file).new :path => tmpfile("bucket_backs"), :backup => ".bak", :content => "foo", :force => true
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       Dir.mkdir(file[:path])
       otherfile = File.join(file[:path], "foo")
       File.open(otherfile, "w") { |f| f.print "yay" }
 
       catalog.apply
 
       backup = file[:path] + ".bak"
       FileTest.should be_directory(backup)
       File.read(File.join(backup, "foo")).should == "yay"
     end
 
-    it "should backup directories to filebuckets by backing up each file separately" do
+    it "should backup directories to filebuckets by backing up each file separately", :fails_on_windows => true do
       bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = Puppet::Type.type(:file).new :path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo", :force => true
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
       catalog.add_resource bucket
 
       Dir.mkdir(file[:path])
       foofile = File.join(file[:path], "foo")
       barfile = File.join(file[:path], "bar")
       File.open(foofile, "w") { |f| f.print "fooyay" }
       File.open(barfile, "w") { |f| f.print "baryay" }
 
 
       foomd5 = Digest::MD5.hexdigest(File.read(foofile))
       barmd5 = Digest::MD5.hexdigest(File.read(barfile))
 
       catalog.apply
 
       bucket.bucket.getfile(foomd5).should == "fooyay"
       bucket.bucket.getfile(barmd5).should == "baryay"
     end
 
     it "should propagate failures encountered when renaming the temporary file" do
       file = Puppet::Type.type(:file).new :path => tmpfile("fail_rename"), :content => "foo"
       file.stubs(:remove_existing) # because it tries to make a backup
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       File.open(file[:path], "w") { |f| f.print "bar" }
 
       File.expects(:rename).raises ArgumentError
 
       lambda { file.write(:content) }.should raise_error(Puppet::Error)
       File.read(file[:path]).should == "bar"
     end
   end
 
   describe "when recursing" do
     def build_path(dir)
       Dir.mkdir(dir)
       File.chmod(0750, dir)
 
       @dirs = [dir]
       @files = []
 
       %w{one two}.each do |subdir|
         fdir = File.join(dir, subdir)
         Dir.mkdir(fdir)
         File.chmod(0750, fdir)
         @dirs << fdir
 
         %w{three}.each do |file|
           ffile = File.join(fdir, file)
           @files << ffile
           File.open(ffile, "w") { |f| f.puts "test #{file}" }
           File.chmod(0640, ffile)
         end
       end
     end
 
-    it "should be able to recurse over a nonexistent file" do
+    it "should be able to recurse over a nonexistent file", :fails_on_windows => true do
       @path = tmpfile("file_integration_tests")
 
       @file = Puppet::Type::File.new(
         :name    => @path,
         :mode    => 0644,
         :recurse => true,
         :backup  => false
       )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
 
       lambda { @file.eval_generate }.should_not raise_error
     end
 
     it "should be able to recursively set properties on existing files" do
       @path = tmpfile("file_integration_tests")
 
       build_path(@path)
 
       @file = Puppet::Type::File.new(
         :name    => @path,
         :mode    => 0644,
         :recurse => true,
         :backup  => false
       )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
 
       @catalog.apply
 
       @dirs.each do |path|
         (File.stat(path).mode & 007777).should == 0755
       end
 
       @files.each do |path|
         (File.stat(path).mode & 007777).should == 0644
       end
     end
 
-    it "should be able to recursively make links to other files" do
+    it "should be able to recursively make links to other files", :fails_on_windows => true do
       source = tmpfile("file_link_integration_source")
 
       build_path(source)
 
       dest = tmpfile("file_link_integration_dest")
 
       @file = Puppet::Type::File.new(:name => dest, :target => source, :recurse => true, :ensure => :link, :backup => false)
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
 
       @catalog.apply
 
       @dirs.each do |path|
         link_path = path.sub(source, dest)
 
         File.lstat(link_path).should be_directory
       end
 
       @files.each do |path|
         link_path = path.sub(source, dest)
 
         File.lstat(link_path).ftype.should == "link"
       end
     end
 
-    it "should be able to recursively copy files" do
+    it "should be able to recursively copy files", :fails_on_windows => true do
       source = tmpfile("file_source_integration_source")
 
       build_path(source)
 
       dest = tmpfile("file_source_integration_dest")
 
       @file = Puppet::Type::File.new(:name => dest, :source => source, :recurse => true, :backup => false)
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
 
       @catalog.apply
 
       @dirs.each do |path|
         newpath = path.sub(source, dest)
 
         File.lstat(newpath).should be_directory
       end
 
       @files.each do |path|
         newpath = path.sub(source, dest)
 
         File.lstat(newpath).ftype.should == "file"
       end
     end
 
     it "should not recursively manage files managed by a more specific explicit file" do
       dir = tmpfile("recursion_vs_explicit_1")
 
       subdir = File.join(dir, "subdir")
       file = File.join(subdir, "file")
 
       FileUtils.mkdir_p(subdir)
       File.open(file, "w") { |f| f.puts "" }
 
       base = Puppet::Type::File.new(:name => dir, :recurse => true, :backup => false, :mode => "755")
       sub = Puppet::Type::File.new(:name => subdir, :recurse => true, :backup => false, :mode => "644")
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource base
       @catalog.add_resource sub
 
       @catalog.apply
 
       (File.stat(file).mode & 007777).should == 0644
     end
 
-    it "should recursively manage files even if there is an explicit file whose name is a prefix of the managed file" do
+    it "should recursively manage files even if there is an explicit file whose name is a prefix of the managed file", :fails_on_windows => true do
       dir = tmpfile("recursion_vs_explicit_2")
 
       managed   = File.join(dir, "file")
       generated = File.join(dir, "file_with_a_name_starting_with_the_word_file")
 
       FileUtils.mkdir_p(dir)
       File.open(managed,   "w") { |f| f.puts "" }
       File.open(generated, "w") { |f| f.puts "" }
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource Puppet::Type::File.new(:name => dir,     :recurse => true, :backup => false, :mode => "755")
       @catalog.add_resource Puppet::Type::File.new(:name => managed, :recurse => true, :backup => false, :mode => "644")
 
       @catalog.apply
 
       (File.stat(generated).mode & 007777).should == 0755
     end
   end
 
-  describe "when generating resources" do
+  describe "when generating resources", :fails_on_windows => true do
     before do
       @source = tmpfile("generating_in_catalog_source")
 
       @dest = tmpfile("generating_in_catalog_dest")
 
       Dir.mkdir(@source)
 
       s1 = File.join(@source, "one")
       s2 = File.join(@source, "two")
 
       File.open(s1, "w") { |f| f.puts "uno" }
       File.open(s2, "w") { |f| f.puts "dos" }
 
       @file = Puppet::Type::File.new(:name => @dest, :source => @source, :recurse => true, :backup => false)
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
     end
 
     it "should add each generated resource to the catalog" do
       @catalog.apply do |trans|
         @catalog.resource(:file, File.join(@dest, "one")).should be_instance_of(@file.class)
         @catalog.resource(:file, File.join(@dest, "two")).should be_instance_of(@file.class)
       end
     end
 
     it "should have an edge to each resource in the relationship graph" do
       @catalog.apply do |trans|
         one = @catalog.resource(:file, File.join(@dest, "one"))
         @catalog.relationship_graph.edge?(@file, one).should be
 
         two = @catalog.resource(:file, File.join(@dest, "two"))
         @catalog.relationship_graph.edge?(@file, two).should be
       end
     end
   end
 
   describe "when copying files" do
     # Ticket #285.
-    it "should be able to copy files with pound signs in their names" do
+    it "should be able to copy files with pound signs in their names", :fails_on_windows => true do
       source = tmpfile("filewith#signs")
 
       dest = tmpfile("destwith#signs")
 
       File.open(source, "w") { |f| f.print "foo" }
 
       file = Puppet::Type::File.new(:name => dest, :source => source)
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       catalog.apply
 
       File.read(dest).should == "foo"
     end
 
-    it "should be able to copy files with spaces in their names" do
+    it "should be able to copy files with spaces in their names", :fails_on_windows => true do
       source = tmpfile("filewith spaces")
 
       dest = tmpfile("destwith spaces")
 
       File.open(source, "w") { |f| f.print "foo" }
       File.chmod(0755, source)
 
       file = Puppet::Type::File.new(:path => dest, :source => source)
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       catalog.apply
 
       File.read(dest).should == "foo"
       (File.stat(dest).mode & 007777).should == 0755
     end
 
-    it "should be able to copy individual files even if recurse has been specified" do
+    it "should be able to copy individual files even if recurse has been specified", :fails_on_windows => true do
       source = tmpfile("source")
       dest = tmpfile("dest")
 
       File.open(source, "w") { |f| f.print "foo" }
 
       file = Puppet::Type::File.new(:name => dest, :source => source, :recurse => true)
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
       catalog.apply
 
       File.read(dest).should == "foo"
     end
   end
 
   it "should be able to create files when 'content' is specified but 'ensure' is not" do
     dest = tmpfile("files_with_content")
 
 
     file = Puppet::Type.type(:file).new(
       :name    => dest,
       :content => "this is some content, yo"
     )
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file
     catalog.apply
 
     File.read(dest).should == "this is some content, yo"
   end
 
   it "should create files with content if both 'content' and 'ensure' are set" do
     dest = tmpfile("files_with_content")
 
 
     file = Puppet::Type.type(:file).new(
       :name    => dest,
       :ensure  => "file",
       :content => "this is some content, yo"
     )
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file
     catalog.apply
 
     File.read(dest).should == "this is some content, yo"
   end
 
-  it "should delete files with sources but that are set for deletion" do
+  it "should delete files with sources but that are set for deletion", :fails_on_windows => true do
     dest = tmpfile("dest_source_with_ensure")
     source = tmpfile("source_source_with_ensure")
     File.open(source, "w") { |f| f.puts "yay" }
     File.open(dest, "w") { |f| f.puts "boo" }
 
 
     file = Puppet::Type.type(:file).new(
       :name   => make_absolute(dest),
       :ensure => :absent,
       :source => source,
       :backup => false
     )
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file
     catalog.apply
 
     File.should_not be_exist(dest)
   end
 
-  describe "when purging files" do
+  describe "when purging files", :fails_on_windows => true do
     before do
       @sourcedir = tmpfile("purge_source")
       @destdir = tmpfile("purge_dest")
       Dir.mkdir(@sourcedir)
       Dir.mkdir(@destdir)
       @sourcefile = File.join(@sourcedir, "sourcefile")
       @copiedfile = File.join(@destdir, "sourcefile")
       @localfile = File.join(@destdir, "localfile")
       @purgee = File.join(@destdir, "to_be_purged")
       File.open(@localfile, "w") { |f| f.puts "rahtest" }
       File.open(@sourcefile, "w") { |f| f.puts "funtest" }
       # this file should get removed
       File.open(@purgee, "w") { |f| f.puts "footest" }
 
 
       @lfobj = Puppet::Type.newfile(
         :title   => "localfile",
         :path    => @localfile,
         :content => "rahtest\n",
         :ensure  => :file,
         :backup  => false
       )
 
 
       @destobj = Puppet::Type.newfile(
         :title   => "destdir",
         :path    => @destdir,
         :source  => @sourcedir,
         :backup  => false,
         :purge   => true,
         :recurse => true
       )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @lfobj, @destobj
     end
 
     it "should still copy remote files" do
       @catalog.apply
       FileTest.should be_exist(@copiedfile)
     end
 
     it "should not purge managed, local files" do
       @catalog.apply
       FileTest.should be_exist(@localfile)
     end
 
     it "should purge files that are neither remote nor otherwise managed" do
       @catalog.apply
       FileTest.should_not be_exist(@purgee)
     end
   end
 end
diff --git a/spec/integration/type/tidy_spec.rb b/spec/integration/type/tidy_spec.rb
index 675aaf4cd..08a24099c 100755
--- a/spec/integration/type/tidy_spec.rb
+++ b/spec/integration/type/tidy_spec.rb
@@ -1,31 +1,31 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet_spec/files'
 require 'puppet/file_bucket/dipper'
 
 describe Puppet::Type.type(:tidy) do
   include PuppetSpec::Files
 
   before do
     Puppet::Util::Storage.stubs(:store)
   end
 
   # Testing #355.
-  it "should be able to remove dead links" do
+  it "should be able to remove dead links", :fails_on_windows => true do
     dir = tmpfile("tidy_link_testing")
     link = File.join(dir, "link")
     target = tmpfile("no_such_file_tidy_link_testing")
     Dir.mkdir(dir)
     File.symlink(target, link)
 
     tidy = Puppet::Type.type(:tidy).new :path => dir, :recurse => true
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource(tidy)
 
     catalog.apply
 
     FileTest.should_not be_symlink(link)
   end
 end
diff --git a/spec/integration/util/autoload_spec.rb b/spec/integration/util/autoload_spec.rb
index 92fc6554c..771e6a718 100755
--- a/spec/integration/util/autoload_spec.rb
+++ b/spec/integration/util/autoload_spec.rb
@@ -1,113 +1,113 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/autoload'
 require 'fileutils'
 
 class AutoloadIntegrator
   @things = []
   def self.newthing(name)
     @things << name
   end
 
   def self.thing?(name)
     @things.include? name
   end
 
   def self.clear
     @things.clear
   end
 end
 
 require 'puppet_spec/files'
 
 describe Puppet::Util::Autoload do
   include PuppetSpec::Files
 
   def with_file(name, *path)
     path = File.join(*path)
     # Now create a file to load
     File.open(path, "w") { |f|
       f.puts "\nAutoloadIntegrator.newthing(:#{name.to_s})\n"
       }
     yield
     File.delete(path)
   end
 
   def with_loader(name, path)
     dir = tmpfile(name + path)
     $LOAD_PATH << dir
     Dir.mkdir(dir)
     rbdir = File.join(dir, path.to_s)
     Dir.mkdir(rbdir)
     loader = Puppet::Util::Autoload.new(name, path)
     yield rbdir, loader
     Dir.rmdir(rbdir)
     Dir.rmdir(dir)
     $LOAD_PATH.pop
     AutoloadIntegrator.clear
   end
 
   it "should make instances available by the loading class" do
     loader = Puppet::Util::Autoload.new("foo", "bar")
     Puppet::Util::Autoload["foo"].should == loader
   end
 
   it "should not fail when asked to load a missing file" do
     Puppet::Util::Autoload.new("foo", "bar").load(:eh).should be_false
   end
 
   it "should load and return true when it successfully loads a file" do
     with_loader("foo", "bar") { |dir,loader|
       with_file(:mything, dir, "mything.rb") {
         loader.load(:mything).should be_true
         loader.should be_loaded(:mything)
         AutoloadIntegrator.should be_thing(:mything)
       }
     }
   end
 
   it "should consider a file loaded when asked for the name without an extension" do
     with_loader("foo", "bar") { |dir,loader|
       with_file(:noext, dir, "noext.rb") {
         loader.load(:noext)
         loader.should be_loaded(:noext)
       }
     }
   end
 
   it "should consider a file loaded when asked for the name with an extension" do
     with_loader("foo", "bar") { |dir,loader|
       with_file(:noext, dir, "withext.rb") {
         loader.load(:withext)
         loader.should be_loaded("withext.rb")
       }
     }
   end
 
   it "should register the fact that the instance is loaded with the Autoload base class" do
     with_loader("foo", "bar") { |dir,loader|
       with_file(:baseload, dir, "baseload.rb") {
         loader.load(:baseload)
         Puppet::Util::Autoload.should be_loaded("bar/withext.rb")
       }
     }
   end
 
-  it "should be able to load files directly from modules" do
+  it "should be able to load files directly from modules", :fails_on_windows => true do
     modulepath = tmpfile("autoload_module_testing")
     libdir = File.join(modulepath, "mymod", "lib", "foo")
     FileUtils.mkdir_p(libdir)
 
     file = File.join(libdir, "plugin.rb")
 
     Puppet[:modulepath] = modulepath
 
     with_loader("foo", "foo") do |dir, loader|
       with_file(:plugin, file.split("/")) do
         loader.load(:plugin)
         loader.should be_loaded("plugin.rb")
       end
     end
   end
 end
diff --git a/spec/unit/application/inspect_spec.rb b/spec/unit/application/inspect_spec.rb
index 77f36f438..630470dc4 100755
--- a/spec/unit/application/inspect_spec.rb
+++ b/spec/unit/application/inspect_spec.rb
@@ -1,282 +1,282 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/inspect'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/catalog/yaml'
 require 'puppet/indirector/report/rest'
 require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::Application::Inspect do
   include PuppetSpec::Files
 
   before :each do
     @inspect = Puppet::Application[:inspect]
     @inspect.preinit
   end
 
   it "should operate in agent run_mode" do
     @inspect.class.run_mode.name.should == :agent
   end
 
   describe "during setup" do
     it "should print its configuration if asked" do
       Puppet[:configprint] = "all"
 
       Puppet.settings.expects(:print_configs).returns(true)
       expect { @inspect.setup }.to exit_with 0
     end
 
     it "should fail if reporting is turned off" do
       Puppet[:report] = false
       lambda { @inspect.setup }.should raise_error(/report=true/)
     end
   end
 
   describe "when executing" do
     before :each do
       Puppet[:report] = true
       @inspect.options[:logset] = true
       Puppet::Transaction::Report::Rest.any_instance.stubs(:save)
       @inspect.setup
     end
 
     it "should retrieve the local catalog" do
       Puppet::Resource::Catalog::Yaml.any_instance.expects(:find).with {|request| request.key == Puppet[:certname] }.returns(Puppet::Resource::Catalog.new)
 
       @inspect.run_command
     end
 
     it "should save the report to REST" do
       Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(Puppet::Resource::Catalog.new)
       Puppet::Transaction::Report::Rest.any_instance.expects(:save).with {|request| request.instance.host == Puppet[:certname] }
 
       @inspect.run_command
     end
 
     it "should audit the specified properties" do
       catalog = Puppet::Resource::Catalog.new
       file = Tempfile.new("foo")
       file.puts("file contents")
       file.close
       resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
       catalog.add_resource(resource)
       Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(catalog)
 
       events = nil
 
       Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
         events = request.instance.resource_statuses.values.first.events
       end
 
       @inspect.run_command
 
       properties = events.inject({}) do |property_values, event|
         property_values.merge(event.property => event.previous_value)
       end
       properties["ensure"].should == :file
       properties["content"].should == "{md5}#{Digest::MD5.hexdigest("file contents\n")}"
       properties.has_key?("target").should == false
     end
 
     it "should set audited to true for all events" do
       catalog = Puppet::Resource::Catalog.new
       file = Tempfile.new("foo")
       resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
       catalog.add_resource(resource)
       Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(catalog)
 
       events = nil
 
       Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
         events = request.instance.resource_statuses.values.first.events
       end
 
       @inspect.run_command
 
       events.each do |event|
         event.audited.should == true
       end
     end
 
     it "should not report irrelevent attributes if the resource is absent" do
       catalog = Puppet::Resource::Catalog.new
       file = Tempfile.new("foo")
       resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
       file.delete
       catalog.add_resource(resource)
       Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(catalog)
 
       events = nil
 
       Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
         events = request.instance.resource_statuses.values.first.events
       end
 
       @inspect.run_command
 
       properties = events.inject({}) do |property_values, event|
         property_values.merge(event.property => event.previous_value)
       end
       properties.should == {"ensure" => :absent}
     end
 
     describe "when archiving to a bucket" do
       before :each do
         Puppet[:archive_files] = true
         Puppet[:archive_file_server] = "filebucketserver"
         @catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(@catalog)
       end
 
       describe "when auditing files" do
         before :each do
           @file = tmpfile("foo")
           @resource = Puppet::Resource.new(:file, @file, :parameters => {:audit => "content"})
           @catalog.add_resource(@resource)
         end
 
         it "should send an existing file to the file bucket" do
           File.open(@file, 'w') { |f| f.write('stuff') }
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).with do |request|
             request.server == Puppet[:archive_file_server]
           end.returns(false)
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).with do |request|
             request.server == Puppet[:archive_file_server] and request.instance.contents == 'stuff'
           end
           @inspect.run_command
         end
 
-        it "should not send unreadable files" do
+        it "should not send unreadable files", :fails_on_windows => true do
           File.open(@file, 'w') { |f| f.write('stuff') }
           File.chmod(0, @file)
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
           @inspect.run_command
         end
 
         it "should not try to send non-existent files" do
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
           @inspect.run_command
         end
 
         it "should not try to send files whose content we are not auditing" do
           @resource[:audit] = "group"
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
           @inspect.run_command
         end
 
         it "should continue if bucketing a file fails" do
           File.open(@file, 'w') { |f| f.write('stuff') }
           Puppet::FileBucketFile::Rest.any_instance.stubs(:head).returns false
           Puppet::FileBucketFile::Rest.any_instance.stubs(:save).raises "failure"
           Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
             @report = request.instance
           end
 
           @inspect.run_command
 
           @report.logs.first.should_not == nil
           @report.logs.first.message.should =~ /Could not back up/
         end
       end
 
       describe "when auditing non-files" do
         before :each do
           Puppet::Type.newtype(:stub_type) do
             newparam(:name) do
               desc "The name var"
               isnamevar
             end
 
             newproperty(:content) do
               desc "content"
               def retrieve
                 :whatever
               end
             end
           end
 
           @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
           @catalog.add_resource(@resource)
         end
 
         after :each do
           Puppet::Type.rmtype(:stub_type)
         end
 
         it "should not try to send non-files" do
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
           @inspect.run_command
         end
       end
     end
 
     describe "when there are failures" do
       before :each do
         Puppet::Type.newtype(:stub_type) do
           newparam(:name) do
             desc "The name var"
             isnamevar
           end
 
           newproperty(:content) do
             desc "content"
             def retrieve
               raise "failed"
             end
           end
         end
 
         @catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(@catalog)
 
         Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
           @report = request.instance
         end
       end
 
       after :each do
         Puppet::Type.rmtype(:stub_type)
       end
 
       it "should mark the report failed and create failed events for each property" do
         @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
         @catalog.add_resource(@resource)
 
         @inspect.run_command
 
         @report.status.should == "failed"
         @report.logs.select{|log| log.message =~ /Could not inspect/}.size.should == 1
         @report.resource_statuses.size.should == 1
         @report.resource_statuses['Stub_type[foo]'].events.size.should == 1
 
         event = @report.resource_statuses['Stub_type[foo]'].events.first
         event.property.should == "content"
         event.status.should == "failure"
         event.audited.should == true
         event.instance_variables.should_not include("@previous_value")
       end
 
       it "should continue to the next resource" do
         @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
         @other_resource = Puppet::Resource.new(:stub_type, 'bar', :parameters => {:audit => "all"})
         @catalog.add_resource(@resource)
         @catalog.add_resource(@other_resource)
 
         @inspect.run_command
 
         @report.resource_statuses.size.should == 2
         @report.resource_statuses.keys.should =~ ['Stub_type[foo]', 'Stub_type[bar]']
       end
     end
   end
 
   after :all do
     Puppet::Resource::Catalog.indirection.reset_terminus_class
     Puppet::Transaction::Report.indirection.terminus_class = :processor
   end
 end
diff --git a/spec/unit/application/master_spec.rb b/spec/unit/application/master_spec.rb
index e36df8caa..636988fd0 100755
--- a/spec/unit/application/master_spec.rb
+++ b/spec/unit/application/master_spec.rb
@@ -1,400 +1,400 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/master'
 require 'puppet/daemon'
 require 'puppet/network/server'
 
-describe Puppet::Application::Master do
+describe Puppet::Application::Master, :fails_on_windows => true do
   before :each do
     @master = Puppet::Application[:master]
     @daemon = stub_everything 'daemon'
     Puppet::Daemon.stubs(:new).returns(@daemon)
     Puppet::Util::Log.stubs(:newdestination)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
     Puppet::Node::Facts.indirection.stubs(:terminus_class=)
     Puppet::Node::Facts.indirection.stubs(:cache_class=)
     Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
     Puppet::SSL::Host.stubs(:ca_location=)
   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 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::SSL::CertificateAuthority.stubs(:instance)
       Puppet::SSL::CertificateAuthority.stubs(:ca?)
       Puppet.settings.stubs(:use)
 
       @master.options.stubs(:[]).with(any_parameters)
     end
 
     it "should abort stating that the master is not supported on Windows" do
       Puppet.features.stubs(:microsoft_windows?).returns(true)
 
       expect { @master.setup }.to raise_error(Puppet::Error, /Puppet master is not supported on Microsoft Windows/)
     end
 
     it "should set log level to debug if --debug was passed" do
       @master.options.stubs(:[]).with(:debug).returns(true)
       @master.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @master.options.stubs(:[]).with(:verbose).returns(true)
       @master.setup
       Puppet::Log.level.should == :info
     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
       Puppet.settings.stubs(:print_configs?).returns(true)
       Puppet.settings.expects(:print_configs).returns(true)
       expect { @master.setup }.to exit_with 0
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
       expect { @master.setup }.to exit_with 1
     end
 
     it "should tell Puppet.settings to use :main,:ssl,:master and :metrics category" do
       Puppet.settings.expects(:use).with(:main,:master,:ssl,:metrics)
 
       @master.setup
     end
 
     it "should cache class in yaml" do
       Puppet::Node.indirection.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 compile if called with --compile" do
       @master.options[:node] = "foo"
       @master.expects(:compile)
       @master.run_command
     end
 
     it "should dispatch to main otherwise" do
       @master.options[:node] = nil
 
       @master.expects(:main)
       @master.run_command
     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)
         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.indirection.expects(:find).with("foo").returns Puppet::Resource::Catalog.new
         $stdout.stubs(:puts)
 
         expect { @master.compile }.to exit_with 0
       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.indirection.expects(:find).returns catalog
 
         catalog.expects(:to_resource).returns("rescat")
 
         @master.options[:node] = "foo"
         @master.expects(:jj).with("rescat")
 
         expect { @master.compile }.to exit_with 0
       end
 
       it "should exit with error code 30 if no catalog can be found" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.indirection.expects(:find).returns nil
         $stderr.expects(:puts)
         expect { @master.compile }.to exit_with 30
       end
 
       it "should exit with error code 30 if there's a failure" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.indirection.expects(:find).raises ArgumentError
         $stderr.expects(:puts)
         expect { @master.compile }.to exit_with 30
       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", :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/configurer/downloader_spec.rb b/spec/unit/configurer/downloader_spec.rb
index 1ffea9b7a..8bb6a3dc6 100755
--- a/spec/unit/configurer/downloader_spec.rb
+++ b/spec/unit/configurer/downloader_spec.rb
@@ -1,200 +1,200 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/configurer/downloader'
 
 describe Puppet::Configurer::Downloader do
   require 'puppet_spec/files'
   include PuppetSpec::Files
   it "should require a name" do
     lambda { Puppet::Configurer::Downloader.new }.should raise_error(ArgumentError)
   end
 
   it "should require a path and a source at initialization" do
     lambda { Puppet::Configurer::Downloader.new("name") }.should raise_error(ArgumentError)
   end
 
   it "should set the name, path and source appropriately" do
     dler = Puppet::Configurer::Downloader.new("facts", "path", "source")
     dler.name.should == "facts"
     dler.path.should == "path"
     dler.source.should == "source"
   end
 
   it "should be able to provide a timeout value" do
     Puppet::Configurer::Downloader.should respond_to(:timeout)
   end
 
   it "should use the configtimeout, converted to an integer, as its timeout" do
     Puppet.settings.expects(:value).with(:configtimeout).returns "50"
     Puppet::Configurer::Downloader.timeout.should == 50
   end
 
   describe "when creating the file that does the downloading" do
     before do
       @dler = Puppet::Configurer::Downloader.new("foo", "path", "source")
     end
 
     it "should create a file instance with the right path and source" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:path] == "path" and opts[:source] == "source" }
       @dler.file
     end
 
     it "should tag the file with the downloader name" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:tag] == "foo" }
       @dler.file
     end
 
     it "should always recurse" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:recurse] == true }
       @dler.file
     end
 
     it "should always purge" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:purge] == true }
       @dler.file
     end
 
     it "should never be in noop" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:noop] == false }
       @dler.file
     end
 
     it "should always set the owner to the current UID" do
       Process.expects(:uid).returns 51
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:owner] == 51 }
       @dler.file
     end
 
     it "should always set the group to the current GID" do
       Process.expects(:gid).returns 61
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:group] == 61 }
       @dler.file
     end
 
     it "should always force the download" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:force] == true }
       @dler.file
     end
 
     it "should never back up when downloading" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:backup] == false }
       @dler.file
     end
 
     it "should support providing an 'ignore' parameter" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:ignore] == [".svn"] }
       @dler = Puppet::Configurer::Downloader.new("foo", "path", "source", ".svn")
       @dler.file
     end
 
     it "should split the 'ignore' parameter on whitespace" do
       Puppet::Type.type(:file).expects(:new).with { |opts| opts[:ignore] == %w{.svn CVS} }
       @dler = Puppet::Configurer::Downloader.new("foo", "path", "source", ".svn CVS")
       @dler.file
     end
   end
 
   describe "when creating the catalog to do the downloading" do
     before do
       @path = make_absolute("/download/path")
       @dler = Puppet::Configurer::Downloader.new("foo", @path, "source")
     end
 
     it "should create a catalog and add the file to it" do
       catalog = @dler.catalog
       catalog.resources.size.should == 1
       catalog.resources.first.class.should == Puppet::Type::File
       catalog.resources.first.name.should == @path
     end
 
     it "should specify that it is not managing a host catalog" do
       @dler.catalog.host_config.should == false
     end
 
   end
 
   describe "when downloading" do
     before do
       @dl_name = tmpfile("downloadpath")
       source_name = tmpfile("source")
       File.open(source_name, 'w') {|f| f.write('hola mundo') }
       @dler = Puppet::Configurer::Downloader.new("foo", @dl_name, source_name)
     end
 
-    it "should not skip downloaded resources when filtering on tags" do
+    it "should not skip downloaded resources when filtering on tags", :fails_on_windows => true do
       Puppet[:tags] = 'maytag'
       @dler.evaluate
 
       File.exists?(@dl_name).should be_true
     end
 
     it "should log that it is downloading" do
       Puppet.expects(:info)
       Timeout.stubs(:timeout)
 
       @dler.evaluate
     end
 
     it "should set a timeout for the download" do
       Puppet::Configurer::Downloader.expects(:timeout).returns 50
       Timeout.expects(:timeout).with(50)
 
       @dler.evaluate
     end
 
     it "should apply the catalog within the timeout block" do
       catalog = mock 'catalog'
       @dler.expects(:catalog).returns(catalog)
 
       Timeout.expects(:timeout).yields
 
       catalog.expects(:apply)
 
       @dler.evaluate
     end
 
     it "should return all changed file paths" do
       trans = mock 'transaction'
 
       catalog = mock 'catalog'
       @dler.expects(:catalog).returns(catalog)
       catalog.expects(:apply).yields(trans)
 
       Timeout.expects(:timeout).yields
 
       resource = mock 'resource'
       resource.expects(:[]).with(:path).returns "/changed/file"
 
       trans.expects(:changed?).returns([resource])
 
       @dler.evaluate.should == %w{/changed/file}
     end
 
     it "should yield the resources if a block is given" do
       trans = mock 'transaction'
 
       catalog = mock 'catalog'
       @dler.expects(:catalog).returns(catalog)
       catalog.expects(:apply).yields(trans)
 
       Timeout.expects(:timeout).yields
 
       resource = mock 'resource'
       resource.expects(:[]).with(:path).returns "/changed/file"
 
       trans.expects(:changed?).returns([resource])
 
       yielded = nil
       @dler.evaluate { |r| yielded = r }
       yielded.should == resource
     end
 
     it "should catch and log exceptions" do
       Puppet.expects(:err)
       Timeout.stubs(:timeout).raises(Puppet::Error, "testing")
 
       lambda { @dler.evaluate }.should_not raise_error
     end
   end
 end
diff --git a/spec/unit/file_bucket/dipper_spec.rb b/spec/unit/file_bucket/dipper_spec.rb
index 4b4c08c61..431b12371 100755
--- a/spec/unit/file_bucket/dipper_spec.rb
+++ b/spec/unit/file_bucket/dipper_spec.rb
@@ -1,113 +1,113 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'pathname'
 
 require 'puppet/file_bucket/dipper'
 require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::FileBucket::Dipper do
   include PuppetSpec::Files
 
   def make_tmp_file(contents)
     file = tmpfile("file_bucket_file")
     File.open(file, 'w') { |f| f.write(contents) }
     file
   end
 
   it "should fail in an informative way when there are failures checking for the file on the server" do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => make_absolute("/my/bucket"))
 
     file = make_tmp_file('contents')
     Puppet::FileBucket::File.indirection.expects(:head).raises ArgumentError
 
     lambda { @dipper.backup(file) }.should raise_error(Puppet::Error)
   end
 
   it "should fail in an informative way when there are failures backing up to the server" do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => make_absolute("/my/bucket"))
 
     file = make_tmp_file('contents')
     Puppet::FileBucket::File.indirection.expects(:head).returns false
     Puppet::FileBucket::File.indirection.expects(:save).raises ArgumentError
 
     lambda { @dipper.backup(file) }.should raise_error(Puppet::Error)
   end
 
-  it "should backup files to a local bucket" do
+  it "should backup files to a local bucket", :fails_on_windows => true do
     Puppet[:bucketdir] = "/non/existent/directory"
     file_bucket = tmpdir("bucket")
 
     @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
 
     file = make_tmp_file('my contents')
     checksum = "2975f560750e71c478b8e3b39a956adb"
     Digest::MD5.hexdigest('my contents').should == checksum
 
     @dipper.backup(file).should == checksum
     File.exists?("#{file_bucket}/2/9/7/5/f/5/6/0/2975f560750e71c478b8e3b39a956adb/contents").should == true
   end
 
   it "should not backup a file that is already in the bucket" do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
 
     file = make_tmp_file('my contents')
     checksum = Digest::MD5.hexdigest('my contents')
 
     Puppet::FileBucket::File.indirection.expects(:head).returns true
     Puppet::FileBucket::File.indirection.expects(:save).never
     @dipper.backup(file).should == checksum
   end
 
   it "should retrieve files from a local bucket" do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
 
     checksum = Digest::MD5.hexdigest('my contents')
 
     request = nil
 
     Puppet::FileBucketFile::File.any_instance.expects(:find).with{ |r| request = r }.once.returns(Puppet::FileBucket::File.new('my contents'))
 
     @dipper.getfile(checksum).should == 'my contents'
 
     request.key.should == "md5/#{checksum}"
   end
 
   it "should backup files to a remote server" do
     @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
 
     file = make_tmp_file('my contents')
     checksum = Digest::MD5.hexdigest('my contents')
 
     real_path = Pathname.new(file).realpath
 
     request1 = nil
     request2 = nil
 
     Puppet::FileBucketFile::Rest.any_instance.expects(:head).with { |r| request1 = r }.once.returns(nil)
     Puppet::FileBucketFile::Rest.any_instance.expects(:save).with { |r| request2 = r }.once
 
     @dipper.backup(file).should == checksum
     [request1, request2].each do |r|
       r.server.should == 'puppetmaster'
       r.port.should == 31337
       r.key.should == "md5/#{checksum}#{real_path}"
     end
   end
 
   it "should retrieve files from a remote server" do
     @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
 
     checksum = Digest::MD5.hexdigest('my contents')
 
     request = nil
 
     Puppet::FileBucketFile::Rest.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new('my contents'))
 
     @dipper.getfile(checksum).should == "my contents"
 
     request.server.should == 'puppetmaster'
     request.port.should == 31337
     request.key.should == "md5/#{checksum}"
   end
 end
diff --git a/spec/unit/file_serving/configuration_spec.rb b/spec/unit/file_serving/configuration_spec.rb
index d76ac9ca8..ed8663853 100755
--- a/spec/unit/file_serving/configuration_spec.rb
+++ b/spec/unit/file_serving/configuration_spec.rb
@@ -1,249 +1,249 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/configuration'
 
-describe Puppet::FileServing::Configuration do
+describe Puppet::FileServing::Configuration, :fails_on_windows => true do
   it "should make :new a private method" do
     proc { Puppet::FileServing::Configuration.new }.should raise_error
   end
 
   it "should return the same configuration each time :create is called" do
     Puppet::FileServing::Configuration.create.should equal(Puppet::FileServing::Configuration.create)
   end
 
   it "should have a method for removing the current configuration instance" do
     old = Puppet::FileServing::Configuration.create
     Puppet::Util::Cacher.expire
     Puppet::FileServing::Configuration.create.should_not equal(old)
   end
 
   after do
     Puppet::Util::Cacher.expire
   end
 end
 
 describe Puppet::FileServing::Configuration do
   include PuppetSpec::Files
 
   before :each do
     @path = make_absolute("/path/to/configuration/file.conf")
     Puppet.settings.stubs(:value).with(:trace).returns(false)
     Puppet.settings.stubs(:value).with(:fileserverconfig).returns(@path)
   end
 
   after :each do
     Puppet::Util::Cacher.expire
   end
 
   describe "when initializing" do
 
     it "should work without a configuration file" do
       FileTest.stubs(:exists?).with(@path).returns(false)
       proc { Puppet::FileServing::Configuration.create }.should_not raise_error
     end
 
     it "should parse the configuration file if present" do
       FileTest.stubs(:exists?).with(@path).returns(true)
       @parser = mock 'parser'
       @parser.expects(:parse).returns({})
       Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
       Puppet::FileServing::Configuration.create
     end
 
     it "should determine the path to the configuration file from the Puppet settings" do
       Puppet::FileServing::Configuration.create
     end
   end
 
   describe "when parsing the configuration file" do
 
     before do
       FileTest.stubs(:exists?).with(@path).returns(true)
       @parser = mock 'parser'
       Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
     end
 
     it "should set the mount list to the results of parsing" do
       @parser.expects(:parse).returns("one" => mock("mount"))
       config = Puppet::FileServing::Configuration.create
       config.mounted?("one").should be_true
     end
 
     it "should not raise exceptions" do
       @parser.expects(:parse).raises(ArgumentError)
       proc { Puppet::FileServing::Configuration.create }.should_not raise_error
     end
 
     it "should replace the existing mount list with the results of reparsing" do
       @parser.expects(:parse).returns("one" => mock("mount"))
       config = Puppet::FileServing::Configuration.create
       config.mounted?("one").should be_true
       # Now parse again
       @parser.expects(:parse).returns("two" => mock('other'))
       config.send(:readconfig, false)
       config.mounted?("one").should be_false
       config.mounted?("two").should be_true
     end
 
     it "should not replace the mount list until the file is entirely parsed successfully" do
       @parser.expects(:parse).returns("one" => mock("mount"))
       @parser.expects(:parse).raises(ArgumentError)
       config = Puppet::FileServing::Configuration.create
       # Now parse again, so the exception gets thrown
       config.send(:readconfig, false)
       config.mounted?("one").should be_true
     end
 
     it "should add modules and plugins mounts even if the file does not exist" do
       FileTest.expects(:exists?).returns false # the file doesn't exist
       config = Puppet::FileServing::Configuration.create
       config.mounted?("modules").should be_true
       config.mounted?("plugins").should be_true
     end
 
     it "should allow all access to modules and plugins if no fileserver.conf exists" do
       FileTest.expects(:exists?).returns false # the file doesn't exist
       modules = stub 'modules', :empty? => true
       Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
       modules.expects(:allow).with('*')
 
       plugins = stub 'plugins', :empty? => true
       Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
       plugins.expects(:allow).with('*')
 
       Puppet::FileServing::Configuration.create
     end
 
     it "should not allow access from all to modules and plugins if the fileserver.conf provided some rules" do
       FileTest.expects(:exists?).returns false # the file doesn't exist
 
       modules = stub 'modules', :empty? => false
       Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
       modules.expects(:allow).with('*').never
 
       plugins = stub 'plugins', :empty? => false
       Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
       plugins.expects(:allow).with('*').never
 
       Puppet::FileServing::Configuration.create
     end
 
     it "should add modules and plugins mounts even if they are not returned by the parser" do
       @parser.expects(:parse).returns("one" => mock("mount"))
       FileTest.expects(:exists?).returns true # the file doesn't exist
       config = Puppet::FileServing::Configuration.create
       config.mounted?("modules").should be_true
       config.mounted?("plugins").should be_true
     end
   end
 
   describe "when finding the specified mount" do
     it "should choose the named mount if one exists" do
       config = Puppet::FileServing::Configuration.create
       config.expects(:mounts).returns("one" => "foo")
       config.find_mount("one", mock('env')).should == "foo"
     end
 
     it "should use the provided environment to find a matching module if the named module cannot be found" do
       config = Puppet::FileServing::Configuration.create
 
       mod = mock 'module'
       env = mock 'environment'
       env.expects(:module).with("foo").returns mod
       mount = mock 'mount'
 
       config.stubs(:mounts).returns("modules" => mount)
       Puppet::Util::Warnings.expects(:notice_once)
       config.find_mount("foo", env).should equal(mount)
     end
 
     it "should return nil if there is no such named mount and no module with the same name exists" do
       config = Puppet::FileServing::Configuration.create
 
       env = mock 'environment'
       env.expects(:module).with("foo").returns nil
 
       mount = mock 'mount'
       config.stubs(:mounts).returns("modules" => mount)
       config.find_mount("foo", env).should be_nil
     end
   end
 
   describe "when finding the mount name and relative path in a request key" do
     before do
       @config = Puppet::FileServing::Configuration.create
       @config.stubs(:find_mount)
 
       @request = stub 'request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => mock("env")
     end
 
     it "should reread the configuration" do
       @config.expects(:readconfig)
 
       @config.split_path(@request)
     end
 
     it "should treat the first field of the URI path as the mount name" do
       @config.expects(:find_mount).with { |name, node| name == "foo" }
 
       @config.split_path(@request)
     end
 
     it "should fail if the mount name is not alpha-numeric" do
       @request.expects(:key).returns "foo&bar/asdf"
 
       lambda { @config.split_path(@request) }.should raise_error(ArgumentError)
     end
 
     it "should support dashes in the mount name" do
       @request.expects(:key).returns "foo-bar/asdf"
 
       lambda { @config.split_path(@request) }.should_not raise_error(ArgumentError)
     end
 
     it "should use the mount name and environment to find the mount" do
       @config.expects(:find_mount).with { |name, env| name == "foo" and env == @request.environment }
       @request.stubs(:node).returns("mynode")
 
       @config.split_path(@request)
     end
 
     it "should return nil if the mount cannot be found" do
       @config.expects(:find_mount).returns nil
 
       @config.split_path(@request).should be_nil
     end
 
     it "should return the mount and the relative path if the mount is found" do
       mount = stub 'mount', :name => "foo"
       @config.expects(:find_mount).returns mount
 
       @config.split_path(@request).should == [mount, "bar/baz"]
     end
 
     it "should remove any double slashes" do
       @request.stubs(:key).returns "foo/bar//baz"
       mount = stub 'mount', :name => "foo"
       @config.expects(:find_mount).returns mount
 
       @config.split_path(@request).should == [mount, "bar/baz"]
     end
 
     it "should return the relative path as nil if it is an empty string" do
       @request.expects(:key).returns "foo"
       mount = stub 'mount', :name => "foo"
       @config.expects(:find_mount).returns mount
 
       @config.split_path(@request).should == [mount, nil]
     end
 
     it "should add 'modules/' to the relative path if the modules mount is used but not specified, for backward compatibility" do
       @request.expects(:key).returns "foo/bar"
       mount = stub 'mount', :name => "modules"
       @config.expects(:find_mount).returns mount
 
       @config.split_path(@request).should == [mount, "foo/bar"]
     end
   end
 end
diff --git a/spec/unit/indirector/certificate_request/ca_spec.rb b/spec/unit/indirector/certificate_request/ca_spec.rb
index 028bc94c6..87d9b6145 100755
--- a/spec/unit/indirector/certificate_request/ca_spec.rb
+++ b/spec/unit/indirector/certificate_request/ca_spec.rb
@@ -1,60 +1,60 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/host'
 require 'puppet/sslcertificates'
 require 'puppet/sslcertificates/ca'
 require 'puppet/indirector/certificate_request/ca'
 
-describe Puppet::SSL::CertificateRequest::Ca do
+describe Puppet::SSL::CertificateRequest::Ca, :fails_on_windows => true do
   include PuppetSpec::Files
 
   before :each do
     Puppet[:ssldir] = tmpdir('ssl')
 
     Puppet::SSL::Host.ca_location = :local
     Puppet[:localcacert] = Puppet[:cacert]
     Puppet::SSLCertificates::CA.new.mkrootcert
 
     @ca = Puppet::SSL::CertificateAuthority.new
   end
 
   after :all do
     Puppet::SSL::Host.ca_location = :none
   end
 
   it "should have documentation" do
     Puppet::SSL::CertificateRequest::Ca.doc.should be_instance_of(String)
   end
 
   it "should use the :csrdir as the collection directory" do
     Puppet.settings.expects(:value).with(:csrdir).returns "/request/dir"
     Puppet::SSL::CertificateRequest::Ca.collection_directory.should == "/request/dir"
   end
 
   it "should overwrite the previous certificate request if allow_duplicate_certs is true" do
     Puppet[:allow_duplicate_certs] = true
     host = Puppet::SSL::Host.new("foo")
     host.generate_certificate_request
     @ca.sign(host.name)
 
     Puppet::SSL::Host.indirection.find("foo").generate_certificate_request
 
     Puppet::SSL::Certificate.indirection.find("foo").name.should == "foo"
     Puppet::SSL::CertificateRequest.indirection.find("foo").name.should == "foo"
     Puppet::SSL::Host.indirection.find("foo").state.should == "requested"
   end
 
   it "should reject a new certificate request if allow_duplicate_certs is false" do
     Puppet[:allow_duplicate_certs] = false
     host = Puppet::SSL::Host.new("bar")
     host.generate_certificate_request
     @ca.sign(host.name)
 
     expect { Puppet::SSL::Host.indirection.find("bar").generate_certificate_request }.should raise_error(/ignoring certificate request/)
 
     Puppet::SSL::Certificate.indirection.find("bar").name.should == "bar"
     Puppet::SSL::CertificateRequest.indirection.find("bar").should be_nil
     Puppet::SSL::Host.indirection.find("bar").state.should == "signed"
   end
 end
diff --git a/spec/unit/indirector/certificate_status/file_spec.rb b/spec/unit/indirector/certificate_status/file_spec.rb
index 5451913a1..c5d4e283f 100755
--- a/spec/unit/indirector/certificate_status/file_spec.rb
+++ b/spec/unit/indirector/certificate_status/file_spec.rb
@@ -1,191 +1,191 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/ssl/host'
 require 'puppet/indirector/certificate_status'
 require 'tempfile'
 
-describe "Puppet::Indirector::CertificateStatus::File" do
+describe "Puppet::Indirector::CertificateStatus::File", :fails_on_windows => true do
   include PuppetSpec::Files
 
   before :all do
     Puppet::SSL::Host.configure_indirection(:file)
   end
 
   before do
     Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
     @terminus = Puppet::SSL::Host.indirection.terminus(:file)
 
     @tmpdir = tmpdir("certificate_status_ca_testing")
     Puppet[:confdir] = @tmpdir
     Puppet[:vardir] = @tmpdir
 
     # localcacert is where each client stores the CA certificate
     # cacert is where the master stores the CA certificate
     # Since we need to play the role of both for testing we need them to be the same and exist
     Puppet[:cacert] = Puppet[:localcacert]
   end
 
   def generate_csr(host)
     host.generate_key
     csr = Puppet::SSL::CertificateRequest.new(host.name)
     csr.generate(host.key.content)
     Puppet::SSL::CertificateRequest.indirection.save(csr)
   end
 
   def sign_csr(host)
     host.desired_state = "signed"
     @terminus.save(Puppet::Indirector::Request.new(:certificate_status, :save, host.name, host))
   end
 
   def generate_signed_cert(host)
     generate_csr(host)
     sign_csr(host)
 
     @terminus.find(Puppet::Indirector::Request.new(:certificate_status, :find, host.name, host))
   end
 
   def generate_revoked_cert(host)
     generate_signed_cert(host)
 
     host.desired_state = "revoked"
 
     @terminus.save(Puppet::Indirector::Request.new(:certificate_status, :save, host.name, host))
   end
 
   it "should be a terminus on SSL::Host" do
     @terminus.should be_instance_of(Puppet::Indirector::CertificateStatus::File)
   end
 
   it "should create a CA instance if none is present" do
     @terminus.ca.should be_instance_of(Puppet::SSL::CertificateAuthority)
   end
 
   describe "when creating the CA" do
     it "should fail if it is not a valid CA" do
       Puppet::SSL::CertificateAuthority.expects(:ca?).returns false
       lambda { @terminus.ca }.should raise_error(ArgumentError, "This process is not configured as a certificate authority")
     end
   end
 
   it "should be indirected with the name 'certificate_status'" do
     Puppet::SSL::Host.indirection.name.should == :certificate_status
   end
 
   describe "when finding" do
     before do
       @host = Puppet::SSL::Host.new("foo")
       Puppet.settings.use(:main)
     end
 
     it "should return the Puppet::SSL::Host when a CSR exists for the host" do
       generate_csr(@host)
       request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
 
       retrieved_host = @terminus.find(request)
 
       retrieved_host.name.should == @host.name
       retrieved_host.certificate_request.content.to_s.chomp.should == @host.certificate_request.content.to_s.chomp
     end
 
     it "should return the Puppet::SSL::Host when a public key exist for the host" do
       generate_signed_cert(@host)
       request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
 
       retrieved_host = @terminus.find(request)
 
       retrieved_host.name.should == @host.name
       retrieved_host.certificate.content.to_s.chomp.should == @host.certificate.content.to_s.chomp
     end
 
     it "should return nil when neither a CSR nor public key exist for the host" do
       request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
       @terminus.find(request).should == nil
     end
   end
 
   describe "when saving" do
     before do
       @host = Puppet::SSL::Host.new("foobar")
       Puppet.settings.use(:main)
     end
 
     describe "when signing a cert" do
       before do
         @host.desired_state = "signed"
         @request = Puppet::Indirector::Request.new(:certificate_status, :save, "foobar", @host)
       end
 
       it "should fail if no CSR is on disk" do
         lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /certificate request/)
       end
 
       it "should sign the on-disk CSR when it is present" do
         signed_host = generate_signed_cert(@host)
 
         signed_host.state.should == "signed"
         Puppet::SSL::Certificate.indirection.find("foobar").should be_instance_of(Puppet::SSL::Certificate)
       end
     end
 
     describe "when revoking a cert" do
       before do
         @request = Puppet::Indirector::Request.new(:certificate_status, :save, "foobar", @host)
       end
 
       it "should fail if no certificate is on disk" do
         @host.desired_state = "revoked"
         lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /Cannot revoke/)
       end
 
       it "should revoke the certificate when it is present" do
         generate_revoked_cert(@host)
 
         @host.state.should == 'revoked'
       end
     end
   end
 
   describe "when deleting" do
     before do
       Puppet.settings.use(:main)
     end
 
     it "should not delete anything if no certificate, request, or key is on disk" do
       host = Puppet::SSL::Host.new("clean_me")
       request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_me", host)
       @terminus.destroy(request).should == "Nothing was deleted"
     end
 
     it "should clean certs, cert requests, keys" do
       signed_host = Puppet::SSL::Host.new("clean_signed_cert")
       generate_signed_cert(signed_host)
       signed_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_signed_cert", signed_host)
       @terminus.destroy(signed_request).should == "Deleted for clean_signed_cert: Puppet::SSL::Certificate, Puppet::SSL::Key"
 
       requested_host = Puppet::SSL::Host.new("clean_csr")
       generate_csr(requested_host)
       csr_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_csr", requested_host)
       @terminus.destroy(csr_request).should == "Deleted for clean_csr: Puppet::SSL::CertificateRequest, Puppet::SSL::Key"
     end
   end
 
   describe "when searching" do
     it "should return a list of all hosts with certificate requests, signed certs, or revoked certs" do
       Puppet.settings.use(:main)
 
       signed_host = Puppet::SSL::Host.new("signed_host")
       generate_signed_cert(signed_host)
 
       requested_host = Puppet::SSL::Host.new("requested_host")
       generate_csr(requested_host)
 
       revoked_host = Puppet::SSL::Host.new("revoked_host")
       generate_revoked_cert(revoked_host)
 
       retrieved_hosts = @terminus.search(Puppet::Indirector::Request.new(:certificate_status, :search, "all", signed_host))
 
       results = retrieved_hosts.map {|h| [h.name, h.state]}.sort{ |h,i| h[0] <=> i[0] }
       results.should == [["ca","signed"],["requested_host","requested"],["revoked_host","revoked"],["signed_host","signed"]]
     end
   end
 end
diff --git a/spec/unit/indirector/file_bucket_file/file_spec.rb b/spec/unit/indirector/file_bucket_file/file_spec.rb
index eb86eee85..ee0b61af1 100755
--- a/spec/unit/indirector/file_bucket_file/file_spec.rb
+++ b/spec/unit/indirector/file_bucket_file/file_spec.rb
@@ -1,273 +1,273 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/file'
 
 describe Puppet::FileBucketFile::File do
   include PuppetSpec::Files
 
   it "should be a subclass of the Code terminus class" do
     Puppet::FileBucketFile::File.superclass.should equal(Puppet::Indirector::Code)
   end
 
   it "should have documentation" do
     Puppet::FileBucketFile::File.doc.should be_instance_of(String)
   end
 
-  describe "non-stubbing tests" do
+  describe "non-stubbing tests", :fails_on_windows => true do
     include PuppetSpec::Files
 
     before do
       Puppet[:bucketdir] = tmpdir('bucketdir')
     end
 
     def save_bucket_file(contents, path = "/who_cares")
       bucket_file = Puppet::FileBucket::File.new(contents)
       Puppet::FileBucket::File.indirection.save(bucket_file, "md5/#{Digest::MD5.hexdigest(contents)}#{path}")
       bucket_file.checksum_data
     end
 
     describe "when servicing a save request" do
       describe "when supplying a path" do
         it "should store the path if not already stored" do
           checksum = save_bucket_file("stuff", "/foo/bar")
           dir_path = "#{Puppet[:bucketdir]}/c/1/3/d/8/8/c/b/c13d88cb4cb02003daedb8a84e5d272a"
           File.read("#{dir_path}/contents").should == "stuff"
           File.read("#{dir_path}/paths").should == "foo/bar\n"
         end
 
         it "should leave the paths file alone if the path is already stored" do
           checksum = save_bucket_file("stuff", "/foo/bar")
           checksum = save_bucket_file("stuff", "/foo/bar")
           dir_path = "#{Puppet[:bucketdir]}/c/1/3/d/8/8/c/b/c13d88cb4cb02003daedb8a84e5d272a"
           File.read("#{dir_path}/contents").should == "stuff"
           File.read("#{dir_path}/paths").should == "foo/bar\n"
         end
 
         it "should store an additional path if the new path differs from those already stored" do
           checksum = save_bucket_file("stuff", "/foo/bar")
           checksum = save_bucket_file("stuff", "/foo/baz")
           dir_path = "#{Puppet[:bucketdir]}/c/1/3/d/8/8/c/b/c13d88cb4cb02003daedb8a84e5d272a"
           File.read("#{dir_path}/contents").should == "stuff"
           File.read("#{dir_path}/paths").should == "foo/bar\nfoo/baz\n"
         end
       end
 
       describe "when not supplying a path" do
         it "should save the file and create an empty paths file" do
           checksum = save_bucket_file("stuff", "")
           dir_path = "#{Puppet[:bucketdir]}/c/1/3/d/8/8/c/b/c13d88cb4cb02003daedb8a84e5d272a"
           File.read("#{dir_path}/contents").should == "stuff"
           File.read("#{dir_path}/paths").should == ""
         end
       end
     end
 
     describe "when servicing a head/find request" do
       describe "when supplying a path" do
         it "should return false/nil if the file isn't bucketed" do
           Puppet::FileBucket::File.indirection.head("md5/0ae2ec1980410229885fe72f7b44fe55/foo/bar").should == false
           Puppet::FileBucket::File.indirection.find("md5/0ae2ec1980410229885fe72f7b44fe55/foo/bar").should == nil
         end
 
         it "should return false/nil if the file is bucketed but with a different path" do
           checksum = save_bucket_file("I'm the contents of a file", '/foo/bar')
           Puppet::FileBucket::File.indirection.head("md5/#{checksum}/foo/baz").should == false
           Puppet::FileBucket::File.indirection.find("md5/#{checksum}/foo/baz").should == nil
         end
 
         it "should return true/file if the file is already bucketed with the given path" do
           contents = "I'm the contents of a file"
           checksum = save_bucket_file(contents, '/foo/bar')
           Puppet::FileBucket::File.indirection.head("md5/#{checksum}/foo/bar").should == true
           find_result = Puppet::FileBucket::File.indirection.find("md5/#{checksum}/foo/bar")
           find_result.should be_a(Puppet::FileBucket::File)
           find_result.checksum.should == "{md5}#{checksum}"
           find_result.to_s.should == contents
         end
       end
 
       describe "when not supplying a path" do
         [false, true].each do |trailing_slash|
           describe "#{trailing_slash ? 'with' : 'without'} a trailing slash" do
             trailing_string = trailing_slash ? '/' : ''
 
             it "should return false/nil if the file isn't bucketed" do
               Puppet::FileBucket::File.indirection.head("md5/0ae2ec1980410229885fe72f7b44fe55#{trailing_string}").should == false
               Puppet::FileBucket::File.indirection.find("md5/0ae2ec1980410229885fe72f7b44fe55#{trailing_string}").should == nil
             end
 
             it "should return true/file if the file is already bucketed" do
               contents = "I'm the contents of a file"
               checksum = save_bucket_file(contents, '/foo/bar')
               Puppet::FileBucket::File.indirection.head("md5/#{checksum}#{trailing_string}").should == true
               find_result = Puppet::FileBucket::File.indirection.find("md5/#{checksum}#{trailing_string}")
               find_result.should be_a(Puppet::FileBucket::File)
               find_result.checksum.should == "{md5}#{checksum}"
               find_result.to_s.should == contents
             end
           end
         end
       end
     end
 
     describe "when diffing files" do
       it "should generate an empty string if there is no diff" do
         checksum = save_bucket_file("I'm the contents of a file")
         Puppet::FileBucket::File.indirection.find("md5/#{checksum}", :diff_with => checksum).should == ''
       end
 
       it "should generate a proper diff if there is a diff" do
         checksum1 = save_bucket_file("foo\nbar\nbaz")
         checksum2 = save_bucket_file("foo\nbiz\nbaz")
         diff = Puppet::FileBucket::File.indirection.find("md5/#{checksum1}", :diff_with => checksum2)
         diff.should == <<HERE
 2c2
 < bar
 ---
 > biz
 HERE
       end
 
       it "should raise an exception if the hash to diff against isn't found" do
         checksum = save_bucket_file("whatever")
         bogus_checksum = "d1bf072d0e2c6e20e3fbd23f022089a1"
         lambda { Puppet::FileBucket::File.indirection.find("md5/#{checksum}", :diff_with => bogus_checksum) }.should raise_error "could not find diff_with #{bogus_checksum}"
       end
 
       it "should return nil if the hash to diff from isn't found" do
         checksum = save_bucket_file("whatever")
         bogus_checksum = "d1bf072d0e2c6e20e3fbd23f022089a1"
         Puppet::FileBucket::File.indirection.find("md5/#{bogus_checksum}", :diff_with => checksum).should == nil
       end
     end
   end
 
   describe "when initializing" do
     it "should use the filebucket settings section" do
       Puppet.settings.expects(:use).with(:filebucket)
       Puppet::FileBucketFile::File.new
     end
   end
 
 
   [true, false].each do |override_bucket_path|
     describe "when bucket path #{if override_bucket_path then 'is' else 'is not' end} overridden" do
       [true, false].each do |supply_path|
         describe "when #{supply_path ? 'supplying' : 'not supplying'} a path" do
           before :each do
             Puppet.settings.stubs(:use)
             @store = Puppet::FileBucketFile::File.new
             @contents = "my content"
 
             @digest = "f2bfa7fc155c4f42cb91404198dda01f"
             @digest.should == Digest::MD5.hexdigest(@contents)
 
             @bucket_dir = tmpdir("bucket")
 
             if override_bucket_path
               Puppet[:bucketdir] = "/bogus/path" # should not be used
             else
               Puppet[:bucketdir] = @bucket_dir
             end
 
             @dir = "#{@bucket_dir}/f/2/b/f/a/7/f/c/f2bfa7fc155c4f42cb91404198dda01f"
             @contents_path = "#{@dir}/contents"
           end
 
           describe "when retrieving files" do
             before :each do
 
               request_options = {}
               if override_bucket_path
                 request_options[:bucket_path] = @bucket_dir
               end
 
               key = "md5/#{@digest}"
               if supply_path
                 key += "/path/to/file"
               end
 
               @request = Puppet::Indirector::Request.new(:indirection_name, :find, key, request_options)
             end
 
             def make_bucketed_file
               FileUtils.mkdir_p(@dir)
               File.open(@contents_path, 'w') { |f| f.write @contents }
             end
 
             it "should return an instance of Puppet::FileBucket::File created with the content if the file exists" do
               make_bucketed_file
 
               if supply_path
                 @store.find(@request).should == nil
                 @store.head(@request).should == false # because path didn't match
               else
                 bucketfile = @store.find(@request)
                 bucketfile.should be_a(Puppet::FileBucket::File)
                 bucketfile.contents.should == @contents
                 @store.head(@request).should == true
               end
             end
 
             it "should return nil if no file is found" do
               @store.find(@request).should be_nil
               @store.head(@request).should == false
             end
           end
 
           describe "when saving files" do
             it "should save the contents to the calculated path" do
               options = {}
               if override_bucket_path
                 options[:bucket_path] = @bucket_dir
               end
 
               key = "md5/#{@digest}"
               if supply_path
                 key += "//path/to/file"
               end
 
               file_instance = Puppet::FileBucket::File.new(@contents, options)
               request = Puppet::Indirector::Request.new(:indirection_name, :save, key, file_instance)
 
               @store.save(request)
               File.read("#{@dir}/contents").should == @contents
             end
           end
         end
       end
     end
   end
 
   describe "when verifying identical files" do
     before do
       # this is the default from spec_helper, but it keeps getting reset at odd times
       Puppet[:bucketdir] = make_absolute("/dev/null/bucket")
 
       @digest = "4a8ec4fa5f01b4ab1a0ab8cbccb709f0"
       @checksum = "{md5}4a8ec4fa5f01b4ab1a0ab8cbccb709f0"
       @dir = make_absolute('/dev/null/bucket/4/a/8/e/c/4/f/a/4a8ec4fa5f01b4ab1a0ab8cbccb709f0')
 
       @contents = "file contents"
 
       @bucket = stub "bucket file"
       @bucket.stubs(:bucket_path)
       @bucket.stubs(:checksum).returns(@checksum)
       @bucket.stubs(:checksum_data).returns(@digest)
       @bucket.stubs(:path).returns(nil)
       @bucket.stubs(:contents).returns("file contents")
     end
 
     it "should raise an error if the files don't match" do
       File.expects(:read).with("#{@dir}/contents").returns("corrupt contents")
       lambda{ Puppet::FileBucketFile::File.new.send(:verify_identical_file!, @bucket) }.should raise_error(Puppet::FileBucket::BucketError)
     end
 
     it "should do nothing if the files match" do
       File.expects(:read).with("#{@dir}/contents").returns("file contents")
       Puppet::FileBucketFile::File.new.send(:verify_identical_file!, @bucket)
     end
 
   end
 end
diff --git a/spec/unit/indirector/resource/ral_spec.rb b/spec/unit/indirector/resource/ral_spec.rb
index cf746cb0c..e38745f05 100755
--- a/spec/unit/indirector/resource/ral_spec.rb
+++ b/spec/unit/indirector/resource/ral_spec.rb
@@ -1,128 +1,128 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "Puppet::Resource::Ral" do
-  describe "find" do
+  describe "find", :fails_on_windows => true do
     before do
       @request = stub 'request', :key => "user/root"
     end
 
     it "should find an existing instance" do
       my_resource    = stub "my user resource"
 
       wrong_instance = stub "wrong user", :name => "bob"
       my_instance    = stub "my user",    :name => "root", :to_resource => my_resource
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ wrong_instance, my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.find(@request).should == my_resource
     end
 
     it "if there is no instance, it should create one", :'fails_on_ruby_1.9.2' => true do
       wrong_instance = stub "wrong user", :name => "bob"
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ wrong_instance, wrong_instance ])
       result = Puppet::Resource::Ral.new.find(@request)
       result.should be_is_a(Puppet::Resource)
       result.title.should == "root"
     end
   end
 
   describe "search" do
     before do
       @request = stub 'request', :key => "user/", :options => {}
     end
 
     it "should convert ral resources into regular resources" do
       my_resource = stub "my user resource"
       my_instance = stub "my user", :name => "root", :to_resource => my_resource
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should filter results by name if there's a name in the key" do
       my_resource    = stub "my user resource"
       my_resource.stubs(:to_resource).returns(my_resource)
       my_resource.stubs(:[]).with(:name).returns("root")
 
       wrong_resource = stub "wrong resource"
       wrong_resource.stubs(:to_resource).returns(wrong_resource)
       wrong_resource.stubs(:[]).with(:name).returns("bad")
 
       my_instance    = stub "my user",    :to_resource => my_resource
       wrong_instance = stub "wrong user", :to_resource => wrong_resource
 
       @request = stub 'request', :key => "user/root", :options => {}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should filter results by query parameters" do
       wrong_resource = stub "my user resource"
       wrong_resource.stubs(:to_resource).returns(wrong_resource)
       wrong_resource.stubs(:[]).with(:name).returns("root")
 
       my_resource = stub "wrong resource"
       my_resource.stubs(:to_resource).returns(my_resource)
       my_resource.stubs(:[]).with(:name).returns("bob")
 
       my_instance    = stub "my user",    :to_resource => my_resource
       wrong_instance = stub "wrong user", :to_resource => wrong_resource
 
       @request = stub 'request', :key => "user/", :options => {:name => "bob"}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should return sorted results" do
       a_resource = stub "alice resource"
       a_resource.stubs(:to_resource).returns(a_resource)
       a_resource.stubs(:title).returns("alice")
 
       b_resource = stub "bob resource"
       b_resource.stubs(:to_resource).returns(b_resource)
       b_resource.stubs(:title).returns("bob")
 
       a_instance = stub "alice user", :to_resource => a_resource
       b_instance = stub "bob user",   :to_resource => b_resource
 
       @request = stub 'request', :key => "user/", :options => {}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ b_instance, a_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [a_resource, b_resource]
     end
   end
 
   describe "save" do
     before do
       @rebuilt_res = stub 'rebuilt instance'
       @ral_res     = stub 'ral resource', :to_resource => @rebuilt_res
       @instance    = stub 'instance', :to_ral => @ral_res
       @request     = stub 'request',  :key => "user/", :instance => @instance
       @catalog     = stub 'catalog'
 
       Puppet::Resource::Catalog.stubs(:new).returns(@catalog)
       @catalog.stubs(:apply)
       @catalog.stubs(:add_resource)
     end
 
     it "should apply a new catalog with a ral object in it" do
       Puppet::Resource::Catalog.expects(:new).returns(@catalog)
       @catalog.expects(:add_resource).with(@ral_res)
       @catalog.expects(:apply)
       Puppet::Resource::Ral.new.save(@request)
     end
 
     it "should return a regular resource that used to be the ral resource" do
       Puppet::Resource::Ral.new.save(@request).should == @rebuilt_res
     end
   end
 end
diff --git a/spec/unit/indirector/resource_type/parser_spec.rb b/spec/unit/indirector/resource_type/parser_spec.rb
index fa2aa10b8..67ea73fd6 100755
--- a/spec/unit/indirector/resource_type/parser_spec.rb
+++ b/spec/unit/indirector/resource_type/parser_spec.rb
@@ -1,149 +1,149 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/resource_type/parser'
 require 'puppet_spec/files'
 
 describe Puppet::Indirector::ResourceType::Parser do
   include PuppetSpec::Files
 
   before do
     @terminus = Puppet::Indirector::ResourceType::Parser.new
     @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo")
     @krt = @request.environment.known_resource_types
   end
 
   it "should be registered with the resource_type indirection" do
     Puppet::Indirector::Terminus.terminus_class(:resource_type, :parser).should equal(Puppet::Indirector::ResourceType::Parser)
   end
 
   describe "when finding" do
     it "should return any found type from the request's environment" do
       type = Puppet::Resource::Type.new(:hostclass, "foo")
       @request.environment.known_resource_types.add(type)
 
       @terminus.find(@request).should == type
     end
 
-    it "should attempt to load the type if none is found in memory" do
+    it "should attempt to load the type if none is found in memory", :fails_on_windows => true do
       dir = tmpdir("find_a_type")
       FileUtils.mkdir_p(dir)
       Puppet[:modulepath] = dir
 
       # Make a new request, since we've reset the env
       @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo::bar")
 
       manifest_path = File.join(dir, "foo", "manifests")
       FileUtils.mkdir_p(manifest_path)
 
       File.open(File.join(manifest_path, "bar.pp"), "w") { |f| f.puts "class foo::bar {}" }
 
       result = @terminus.find(@request)
       result.should be_instance_of(Puppet::Resource::Type)
       result.name.should == "foo::bar"
     end
 
     it "should return nil if no type can be found" do
       @terminus.find(@request).should be_nil
     end
 
     it "should prefer definitions to nodes" do
       type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
       node = @krt.add(Puppet::Resource::Type.new(:node, "foo"))
 
       @terminus.find(@request).should == type
     end
   end
 
   describe "when searching" do
     before do
       @request.key = "*"
     end
 
     it "should use the request's environment's list of known resource types" do
       @request.environment.known_resource_types.expects(:hostclasses).returns({})
 
       @terminus.search(@request)
     end
 
     it "should return all results if '*' is provided as the search string" do
       @request.key = "*"
       type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
       node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
       define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
 
       result = @terminus.search(@request)
       result.should be_include(type)
       result.should be_include(node)
       result.should be_include(define)
     end
 
     it "should treat any search string not '*' as a regex" do
       @request.key = "a"
       foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
       bar = @krt.add(Puppet::Resource::Type.new(:hostclass, "bar"))
       baz = @krt.add(Puppet::Resource::Type.new(:hostclass, "baz"))
 
       result = @terminus.search(@request)
       result.should be_include(bar)
       result.should be_include(baz)
       result.should_not be_include(foo)
     end
 
     it "should fail if a provided search string is not '*' and is not a valid regex" do
       @request.key = "*foo*"
 
       # Add one instance so we don't just get an empty array"
       @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
       lambda { @terminus.search(@request) }.should raise_error(ArgumentError)
     end
 
     it "should return all known types" do
       type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
       node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
       define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
 
       result = @terminus.search(@request)
       result.should be_include(type)
       result.should be_include(node)
       result.should be_include(define)
     end
 
     it "should not return the 'main' class" do
       main = @krt.add(Puppet::Resource::Type.new(:hostclass, ""))
 
       # So there is a return value
       foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
 
       @terminus.search(@request).should_not be_include(main)
     end
 
     it "should return nil if no types can be found" do
       @terminus.search(@request).should be_nil
     end
 
-    it "should load all resource types from all search paths" do
+    it "should load all resource types from all search paths", :fails_on_windows => true do
       dir = tmpdir("searching_in_all")
       first = File.join(dir, "first")
       second = File.join(dir, "second")
       FileUtils.mkdir_p(first)
       FileUtils.mkdir_p(second)
       Puppet[:modulepath] = "#{first}#{File::PATH_SEPARATOR}#{second}"
 
       # Make a new request, since we've reset the env
       @request = Puppet::Indirector::Request.new(:resource_type, :search, "*")
 
       onepath = File.join(first, "one", "manifests")
       FileUtils.mkdir_p(onepath)
       twopath = File.join(first, "two", "manifests")
       FileUtils.mkdir_p(twopath)
 
       File.open(File.join(onepath, "oneklass.pp"), "w") { |f| f.puts "class one::oneklass {}" }
       File.open(File.join(twopath, "twoklass.pp"), "w") { |f| f.puts "class two::twoklass {}" }
 
       result = @terminus.search(@request)
       result.find { |t| t.name == "one::oneklass" }.should be_instance_of(Puppet::Resource::Type)
       result.find { |t| t.name == "two::twoklass" }.should be_instance_of(Puppet::Resource::Type)
     end
   end
 end
diff --git a/spec/unit/network/http_pool_spec.rb b/spec/unit/network/http_pool_spec.rb
index 41105ece9..223b16d01 100755
--- a/spec/unit/network/http_pool_spec.rb
+++ b/spec/unit/network/http_pool_spec.rb
@@ -1,202 +1,202 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/network/http_pool'
 
 describe Puppet::Network::HttpPool do
   after do
     Puppet::Util::Cacher.expire
     Puppet::Network::HttpPool.clear_http_instances
     Puppet::Network::HttpPool.instance_variable_set("@ssl_host", nil)
   end
 
   it "should have keep-alive disabled" do
     Puppet::Network::HttpPool::HTTP_KEEP_ALIVE.should be_false
   end
 
   it "should use the global SSL::Host instance to get its certificate information" do
     host = mock 'host'
     Puppet::SSL::Host.expects(:localhost).with.returns host
     Puppet::Network::HttpPool.ssl_host.should equal(host)
   end
 
   describe "when managing http instances" do
     def stub_settings(settings)
       settings.each do |param, value|
         Puppet.settings.stubs(:value).with(param).returns(value)
       end
     end
 
     before do
       # All of the cert stuff is tested elsewhere
       Puppet::Network::HttpPool.stubs(:cert_setup)
     end
 
     it "should return an http instance created with the passed host and port" do
       http = stub 'http', :use_ssl= => nil, :read_timeout= => nil, :open_timeout= => nil, :started? => false
       Net::HTTP.expects(:new).with("me", 54321, nil, nil).returns(http)
       Puppet::Network::HttpPool.http_instance("me", 54321).should equal(http)
     end
 
     it "should enable ssl on the http instance" do
       Puppet::Network::HttpPool.http_instance("me", 54321).instance_variable_get("@use_ssl").should be_true
     end
 
     it "should set the read timeout" do
       Puppet::Network::HttpPool.http_instance("me", 54321).read_timeout.should == 120
     end
 
     it "should set the open timeout" do
       Puppet::Network::HttpPool.http_instance("me", 54321).open_timeout.should == 120
     end
 
     it "should create the http instance with the proxy host and port set if the http_proxy is not set to 'none'" do
       stub_settings :http_proxy_host => "myhost", :http_proxy_port => 432, :configtimeout => 120
       Puppet::Network::HttpPool.http_instance("me", 54321).open_timeout.should == 120
     end
 
     describe "and http keep-alive is enabled" do
       before do
         Puppet::Network::HttpPool.stubs(:keep_alive?).returns true
       end
 
       it "should cache http instances" do
         stub_settings :http_proxy_host => "myhost", :http_proxy_port => 432, :configtimeout => 120
         old = Puppet::Network::HttpPool.http_instance("me", 54321)
         Puppet::Network::HttpPool.http_instance("me", 54321).should equal(old)
       end
 
       it "should have a mechanism for getting a new http instance instead of the cached instance" do
         stub_settings :http_proxy_host => "myhost", :http_proxy_port => 432, :configtimeout => 120
         old = Puppet::Network::HttpPool.http_instance("me", 54321)
         Puppet::Network::HttpPool.http_instance("me", 54321, true).should_not equal(old)
       end
 
       it "should close existing, open connections when requesting a new connection" do
         stub_settings :http_proxy_host => "myhost", :http_proxy_port => 432, :configtimeout => 120
         old = Puppet::Network::HttpPool.http_instance("me", 54321)
         old.expects(:started?).returns(true)
         old.expects(:finish)
         Puppet::Network::HttpPool.http_instance("me", 54321, true)
       end
 
-      it "should have a mechanism for clearing the http cache" do
+      it "should have a mechanism for clearing the http cache", :fails_on_windows => true do
         stub_settings :http_proxy_host => "myhost", :http_proxy_port => 432, :configtimeout => 120
         old = Puppet::Network::HttpPool.http_instance("me", 54321)
         Puppet::Network::HttpPool.http_instance("me", 54321).should equal(old)
         old = Puppet::Network::HttpPool.http_instance("me", 54321)
         Puppet::Network::HttpPool.clear_http_instances
         Puppet::Network::HttpPool.http_instance("me", 54321).should_not equal(old)
       end
 
       it "should close open http connections when clearing the cache" do
         stub_settings :http_proxy_host => "myhost", :http_proxy_port => 432, :configtimeout => 120
         one = Puppet::Network::HttpPool.http_instance("me", 54321)
         one.expects(:started?).returns(true)
         one.expects(:finish).returns(true)
         Puppet::Network::HttpPool.clear_http_instances
       end
 
       it "should not close unopened http connections when clearing the cache" do
         stub_settings :http_proxy_host => "myhost", :http_proxy_port => 432, :configtimeout => 120
         one = Puppet::Network::HttpPool.http_instance("me", 54321)
         one.expects(:started?).returns(false)
         one.expects(:finish).never
         Puppet::Network::HttpPool.clear_http_instances
       end
     end
 
     describe "and http keep-alive is disabled" do
       before do
         Puppet::Network::HttpPool.stubs(:keep_alive?).returns false
       end
 
       it "should not cache http instances" do
         stub_settings :http_proxy_host => "myhost", :http_proxy_port => 432, :configtimeout => 120
         old = Puppet::Network::HttpPool.http_instance("me", 54321)
         Puppet::Network::HttpPool.http_instance("me", 54321).should_not equal(old)
       end
     end
 
     after do
       Puppet::Network::HttpPool.clear_http_instances
     end
   end
 
   describe "when adding certificate information to http instances" do
     before do
       @http = mock 'http'
       [:cert_store=, :verify_mode=, :ca_file=, :cert=, :key=].each { |m| @http.stubs(m) }
       @store = stub 'store'
 
       @cert = stub 'cert', :content => "real_cert"
       @key = stub 'key', :content => "real_key"
       @host = stub 'host', :certificate => @cert, :key => @key, :ssl_store => @store
 
       Puppet[:confdir] = "/sometthing/else"
       Puppet.settings.stubs(:value).returns "/some/file"
       Puppet.settings.stubs(:value).with(:hostcert).returns "/host/cert"
       Puppet.settings.stubs(:value).with(:localcacert).returns "/local/ca/cert"
 
       FileTest.stubs(:exist?).with("/host/cert").returns true
       FileTest.stubs(:exist?).with("/local/ca/cert").returns true
 
       Puppet::Network::HttpPool.stubs(:ssl_host).returns @host
     end
 
     after do
       Puppet.settings.clear
     end
 
     it "should do nothing if no host certificate is on disk" do
       FileTest.expects(:exist?).with("/host/cert").returns false
       @http.expects(:cert=).never
       Puppet::Network::HttpPool.cert_setup(@http)
     end
 
     it "should do nothing if no local certificate is on disk" do
       FileTest.expects(:exist?).with("/local/ca/cert").returns false
       @http.expects(:cert=).never
       Puppet::Network::HttpPool.cert_setup(@http)
     end
 
     it "should add a certificate store from the ssl host" do
       @http.expects(:cert_store=).with(@store)
 
       Puppet::Network::HttpPool.cert_setup(@http)
     end
 
     it "should add the client certificate" do
       @http.expects(:cert=).with("real_cert")
 
       Puppet::Network::HttpPool.cert_setup(@http)
     end
 
     it "should add the client key" do
       @http.expects(:key=).with("real_key")
 
       Puppet::Network::HttpPool.cert_setup(@http)
     end
 
     it "should set the verify mode to OpenSSL::SSL::VERIFY_PEER" do
       @http.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
 
       Puppet::Network::HttpPool.cert_setup(@http)
     end
 
     it "should set the ca file" do
       Puppet.settings.stubs(:value).returns "/some/file"
       FileTest.stubs(:exist?).with(Puppet[:hostcert]).returns true
 
       Puppet.settings.stubs(:value).with(:localcacert).returns "/ca/cert/file"
       FileTest.stubs(:exist?).with("/ca/cert/file").returns true
       @http.expects(:ca_file=).with("/ca/cert/file")
 
       Puppet::Network::HttpPool.cert_setup(@http)
     end
 
     it "should set up certificate information when creating http instances" do
       Puppet::Network::HttpPool.expects(:cert_setup).with { |i| i.is_a?(Net::HTTP) }
       Puppet::Network::HttpPool.http_instance("one", "two")
     end
   end
 end
diff --git a/spec/unit/property_spec.rb b/spec/unit/property_spec.rb
index 7728b5d40..99d4bc7c5 100755
--- a/spec/unit/property_spec.rb
+++ b/spec/unit/property_spec.rb
@@ -1,409 +1,409 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/property'
 
 describe Puppet::Property do
   before do
     @class = Class.new(Puppet::Property) do
       @name = :foo
     end
     @class.initvars
     @provider = mock 'provider'
     @resource = stub 'resource', :provider => @provider
     @resource.stub_everything
     @property = @class.new :resource => @resource
   end
 
   it "should return its name as a string when converted to a string" do
     @property.to_s.should == @property.name.to_s
   end
 
   it "should be able to look up the modified name for a given value" do
     @class.newvalue(:foo)
     @class.value_name("foo").should == :foo
   end
 
   it "should be able to look up the modified name for a given value matching a regex" do
     @class.newvalue(%r{.})
     @class.value_name("foo").should == %r{.}
   end
 
   it "should be able to look up a given value option" do
     @class.newvalue(:foo, :event => :whatever)
     @class.value_option(:foo, :event).should == :whatever
   end
 
   it "should be able to specify required features" do
     @class.should respond_to(:required_features=)
   end
 
   {"one" => [:one],:one => [:one],%w{a} => [:a],[:b] => [:b],%w{one two} => [:one,:two],[:a,:b] => [:a,:b]}.each { |in_value,out_value|
     it "should always convert required features into an array of symbols (e.g. #{in_value.inspect} --> #{out_value.inspect})" do
       @class.required_features = in_value
       @class.required_features.should == out_value
     end
   }
 
   it "should be able to shadow metaparameters" do
     @property.must respond_to(:shadow)
   end
 
   describe "when returning the default event name" do
     before do
       @resource = stub 'resource'
       @instance = @class.new(:resource => @resource)
       @instance.stubs(:should).returns "myval"
     end
 
     it "should use the current 'should' value to pick the event name" do
       @instance.expects(:should).returns "myvalue"
       @class.expects(:value_option).with('myvalue', :event).returns :event_name
 
       @instance.event_name
     end
 
     it "should return any event defined with the specified value" do
       @instance.expects(:should).returns :myval
       @class.expects(:value_option).with(:myval, :event).returns :event_name
 
       @instance.event_name.should == :event_name
     end
 
     describe "and the property is 'ensure'" do
       before do
         @instance.stubs(:name).returns :ensure
         @resource.expects(:type).returns :mytype
       end
 
       it "should use <type>_created if the 'should' value is 'present'" do
         @instance.expects(:should).returns :present
         @instance.event_name.should == :mytype_created
       end
 
       it "should use <type>_removed if the 'should' value is 'absent'" do
         @instance.expects(:should).returns :absent
         @instance.event_name.should == :mytype_removed
       end
 
       it "should use <type>_changed if the 'should' value is not 'absent' or 'present'" do
         @instance.expects(:should).returns :foo
         @instance.event_name.should == :mytype_changed
       end
 
       it "should use <type>_changed if the 'should value is nil" do
         @instance.expects(:should).returns nil
         @instance.event_name.should == :mytype_changed
       end
     end
 
     it "should use <property>_changed if the property is not 'ensure'" do
       @instance.stubs(:name).returns :myparam
       @instance.expects(:should).returns :foo
       @instance.event_name.should == :myparam_changed
     end
 
     it "should use <property>_changed if no 'should' value is set" do
       @instance.stubs(:name).returns :myparam
       @instance.expects(:should).returns nil
       @instance.event_name.should == :myparam_changed
     end
   end
 
-  describe "when creating an event" do
+  describe "when creating an event", :fails_on_windows => true do
     before do
       @event = Puppet::Transaction::Event.new
 
       # Use a real resource so we can test the event creation integration
       @resource = Puppet::Type.type(:mount).new :name => "foo"
       @instance = @class.new(:resource => @resource)
       @instance.stubs(:should).returns "myval"
     end
 
     it "should use an event from the resource as the base event" do
       event = Puppet::Transaction::Event.new
       @resource.expects(:event).returns event
 
       @instance.event.should equal(event)
     end
 
     it "should have the default event name" do
       @instance.expects(:event_name).returns :my_event
       @instance.event.name.should == :my_event
     end
 
     it "should have the property's name" do
       @instance.event.property.should == @instance.name.to_s
     end
 
     it "should have the 'should' value set" do
       @instance.stubs(:should).returns "foo"
       @instance.event.desired_value.should == "foo"
     end
 
     it "should provide its path as the source description" do
       @instance.stubs(:path).returns "/my/param"
       @instance.event.source_description.should == "/my/param"
     end
   end
 
   describe "when shadowing metaparameters" do
     before do
       @shadow_class = Class.new(Puppet::Property) do
         @name = :alias
       end
       @shadow_class.initvars
     end
 
     it "should create an instance of the metaparameter at initialization" do
       Puppet::Type.metaparamclass(:alias).expects(:new).with(:resource => @resource)
 
       @shadow_class.new :resource => @resource
     end
 
     it "should munge values using the shadow's munge method" do
       shadow = mock 'shadow'
       Puppet::Type.metaparamclass(:alias).expects(:new).returns shadow
 
       shadow.expects(:munge).with "foo"
 
       property = @shadow_class.new :resource => @resource
       property.munge("foo")
     end
   end
 
   describe "when defining new values" do
     it "should define a method for each value created with a block that's not a regex" do
       @class.newvalue(:foo) { }
       @property.must respond_to(:set_foo)
     end
   end
 
   describe "when assigning the value" do
     it "should just set the 'should' value" do
       @property.value = "foo"
       @property.should.must == "foo"
     end
 
     it "should validate each value separately" do
       @property.expects(:validate).with("one")
       @property.expects(:validate).with("two")
 
       @property.value = %w{one two}
     end
 
     it "should munge each value separately and use any result as the actual value" do
       @property.expects(:munge).with("one").returns :one
       @property.expects(:munge).with("two").returns :two
 
       # Do this so we get the whole array back.
       @class.array_matching = :all
 
       @property.value = %w{one two}
       @property.should.must == [:one, :two]
     end
 
     it "should return any set value" do
       (@property.value = :one).should == :one
     end
   end
 
   describe "when returning the value" do
     it "should return nil if no value is set" do
       @property.should.must be_nil
     end
 
     it "should return the first set 'should' value if :array_matching is set to :first" do
       @class.array_matching = :first
       @property.should = %w{one two}
       @property.should.must == "one"
     end
 
     it "should return all set 'should' values as an array if :array_matching is set to :all" do
       @class.array_matching = :all
       @property.should = %w{one two}
       @property.should.must == %w{one two}
     end
 
     it "should default to :first array_matching" do
       @class.array_matching.should == :first
     end
 
     it "should unmunge the returned value if :array_matching is set to :first" do
       @property.class.unmunge do |v| v.to_sym end
       @class.array_matching = :first
       @property.should = %w{one two}
 
       @property.should.must == :one
     end
 
     it "should unmunge all the returned values if :array_matching is set to :all" do
       @property.class.unmunge do |v| v.to_sym end
       @class.array_matching = :all
       @property.should = %w{one two}
 
       @property.should.must == [:one, :two]
     end
   end
 
   describe "when validating values" do
     it "should do nothing if no values or regexes have been defined" do
       lambda { @property.should = "foo" }.should_not raise_error
     end
 
     it "should fail if the value is not a defined value or alias and does not match a regex" do
       @class.newvalue(:foo)
 
       lambda { @property.should = "bar" }.should raise_error
     end
 
     it "should succeeed if the value is one of the defined values" do
       @class.newvalue(:foo)
 
       lambda { @property.should = :foo }.should_not raise_error
     end
 
     it "should succeeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
       @class.newvalue(:foo)
 
       lambda { @property.should = "foo" }.should_not raise_error
     end
 
     it "should succeeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
       @class.newvalue("foo")
 
       lambda { @property.should = :foo }.should_not raise_error
     end
 
     it "should succeed if the value is one of the defined aliases" do
       @class.newvalue("foo")
       @class.aliasvalue("bar", "foo")
 
       lambda { @property.should = :bar }.should_not raise_error
     end
 
     it "should succeed if the value matches one of the regexes" do
       @class.newvalue(/./)
 
       lambda { @property.should = "bar" }.should_not raise_error
     end
 
     it "should validate that all required features are present" do
       @class.newvalue(:foo, :required_features => [:a, :b])
 
       @provider.expects(:satisfies?).with([:a, :b]).returns true
 
       @property.should = :foo
     end
 
     it "should fail if required features are missing" do
       @class.newvalue(:foo, :required_features => [:a, :b])
 
       @provider.expects(:satisfies?).with([:a, :b]).returns false
 
       lambda { @property.should = :foo }.should raise_error(Puppet::Error)
     end
 
     it "should internally raise an ArgumentError if required features are missing" do
       @class.newvalue(:foo, :required_features => [:a, :b])
 
       @provider.expects(:satisfies?).with([:a, :b]).returns false
 
       lambda { @property.validate_features_per_value :foo }.should raise_error(ArgumentError)
     end
 
     it "should validate that all required features are present for regexes" do
       value = @class.newvalue(/./, :required_features => [:a, :b])
 
       @provider.expects(:satisfies?).with([:a, :b]).returns true
 
       @property.should = "foo"
     end
 
     it "should support specifying an individual required feature" do
       value = @class.newvalue(/./, :required_features => :a)
 
       @provider.expects(:satisfies?).returns true
 
       @property.should = "foo"
     end
   end
 
   describe "when munging values" do
     it "should do nothing if no values or regexes have been defined" do
       @property.munge("foo").should == "foo"
     end
 
     it "should return return any matching defined values" do
       @class.newvalue(:foo)
       @property.munge("foo").should == :foo
     end
 
     it "should return any matching aliases" do
       @class.newvalue(:foo)
       @class.aliasvalue(:bar, :foo)
       @property.munge("bar").should == :foo
     end
 
     it "should return the value if it matches a regex" do
       @class.newvalue(/./)
       @property.munge("bar").should == "bar"
     end
 
     it "should return the value if no other option is matched" do
       @class.newvalue(:foo)
       @property.munge("bar").should == "bar"
     end
   end
 
   describe "when syncing the 'should' value" do
     it "should set the value" do
       @class.newvalue(:foo)
       @property.should = :foo
       @property.expects(:set).with(:foo)
       @property.sync
     end
   end
 
   describe "when setting a value" do
     it "should catch exceptions and raise Puppet::Error" do
       @class.newvalue(:foo) { raise "eh" }
       lambda { @property.set(:foo) }.should raise_error(Puppet::Error)
     end
 
     describe "that was defined without a block" do
       it "should call the settor on the provider" do
         @class.newvalue(:bar)
         @provider.expects(:foo=).with :bar
         @property.set(:bar)
       end
     end
 
     describe "that was defined with a block" do
       it "should call the method created for the value if the value is not a regex" do
         @class.newvalue(:bar) {}
         @property.expects(:set_bar)
         @property.set(:bar)
       end
 
       it "should call the provided block if the value is a regex" do
         @class.newvalue(/./) { self.test }
         @property.expects(:test)
         @property.set("foo")
       end
     end
   end
 
   describe "when producing a change log" do
     it "should say 'defined' when the current value is 'absent'" do
       @property.change_to_s(:absent, "foo").should =~ /^defined/
     end
 
     it "should say 'undefined' when the new value is 'absent'" do
       @property.change_to_s("foo", :absent).should =~ /^undefined/
     end
 
     it "should say 'changed' when neither value is 'absent'" do
       @property.change_to_s("foo", "bar").should =~ /changed/
     end
   end
 end
diff --git a/spec/unit/provider/exec/shell_spec.rb b/spec/unit/provider/exec/shell_spec.rb
index 90047b9d6..4e1f00281 100755
--- a/spec/unit/provider/exec/shell_spec.rb
+++ b/spec/unit/provider/exec/shell_spec.rb
@@ -1,50 +1,50 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:exec).provider(:shell)
 
-describe provider_class do
+describe provider_class, :fails_on_windows => true do
   before :each do
     @resource = Puppet::Resource.new(:exec, 'foo')
     @provider = provider_class.new(@resource)
   end
 
   describe "#run" do
     it "should be able to run builtin shell commands" do
       output, status = @provider.run("if [ 1 = 1 ]; then echo 'blah'; fi")
       status.exitstatus.should == 0
       output.should == "blah\n"
     end
 
     it "should be able to run commands with single quotes in them" do
       output, status = @provider.run("echo 'foo  bar'")
       status.exitstatus.should == 0
       output.should == "foo  bar\n"
     end
 
     it "should be able to run commands with double quotes in them" do
       output, status = @provider.run('echo "foo  bar"')
       status.exitstatus.should == 0
       output.should == "foo  bar\n"
     end
 
     it "should be able to run multiple commands separated by a semicolon" do
       output, status = @provider.run("echo 'foo' ; echo 'bar'")
       status.exitstatus.should == 0
       output.should == "foo\nbar\n"
     end
 
     it "should be able to read values from the environment parameter" do
       @resource[:environment] = "FOO=bar"
       output, status = @provider.run("echo $FOO")
       status.exitstatus.should == 0
       output.should == "bar\n"
     end
   end
 
   describe "#validatecmd" do
     it "should always return true because builtins don't need path or to be fully qualified" do
       @provider.validatecmd('whateverdoesntmatter').should == true
     end
   end
 end
diff --git a/spec/unit/provider/host/parsed_spec.rb b/spec/unit/provider/host/parsed_spec.rb
index 9cb5890cc..fa41d82e5 100755
--- a/spec/unit/provider/host/parsed_spec.rb
+++ b/spec/unit/provider/host/parsed_spec.rb
@@ -1,197 +1,197 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 
 require 'puppet_spec/files'
 
 provider_class = Puppet::Type.type(:host).provider(:parsed)
 
-describe provider_class do
+describe provider_class, :fails_on_windows => true do
   include PuppetSpec::Files
 
   before do
     @host_class = Puppet::Type.type(:host)
     @provider = @host_class.provider(:parsed)
     @hostfile = tmpfile('hosts')
     @provider.any_instance.stubs(:target).returns @hostfile
   end
 
   after :each do
     @provider.initvars
   end
 
   def mkhost(args)
     hostresource = Puppet::Type::Host.new(:name => args[:name])
     hostresource.stubs(:should).with(:target).returns @hostfile
 
     # Using setters of provider to build our testobject
     # Note: We already proved, that in case of host_aliases
     # the provider setter "host_aliases=(value)" will be
     # called with the joined array, so we just simulate that
     host = @provider.new(hostresource)
     args.each do |property,value|
       value = value.join(" ") if property == :host_aliases and value.is_a?(Array)
       host.send("#{property}=", value)
     end
     host
   end
 
   def genhost(host)
     @provider.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     File.stubs(:chown)
     File.stubs(:chmod)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
     host.flush
     @provider.target_object(@hostfile).read
   end
 
   describe "when parsing a line with ip and hostname" do
 
     it "should parse an ipv4 from the first field" do
       @provider.parse_line("127.0.0.1    localhost")[:ip].should == "127.0.0.1"
     end
 
     it "should parse an ipv6 from the first field" do
       @provider.parse_line("::1     localhost")[:ip].should == "::1"
     end
 
     it "should parse the name from the second field" do
       @provider.parse_line("::1     localhost")[:name].should == "localhost"
     end
 
     it "should set an empty comment" do
       @provider.parse_line("::1     localhost")[:comment].should == ""
     end
 
     it "should set host_aliases to :absent" do
       @provider.parse_line("::1     localhost")[:host_aliases].should == :absent
     end
 
   end
 
   describe "when parsing a line with ip, hostname and comment" do
     before do
       @testline = "127.0.0.1   localhost # A comment with a #-char"
     end
 
     it "should parse the ip from the first field" do
       @provider.parse_line(@testline)[:ip].should == "127.0.0.1"
     end
 
     it "should parse the hostname from the second field" do
       @provider.parse_line(@testline)[:name].should == "localhost"
     end
 
     it "should parse the comment after the first '#' character" do
       @provider.parse_line(@testline)[:comment].should == 'A comment with a #-char'
     end
 
   end
 
   describe "when parsing a line with ip, hostname and aliases" do
 
     it "should parse alias from the third field" do
       @provider.parse_line("127.0.0.1   localhost   localhost.localdomain")[:host_aliases].should == "localhost.localdomain"
     end
 
     it "should parse multiple aliases" do
       @provider.parse_line("127.0.0.1 host alias1 alias2")[:host_aliases].should == 'alias1 alias2'
       @provider.parse_line("127.0.0.1 host alias1\talias2")[:host_aliases].should == 'alias1 alias2'
       @provider.parse_line("127.0.0.1 host alias1\talias2   alias3")[:host_aliases].should == 'alias1 alias2 alias3'
     end
 
   end
 
   describe "when parsing a line with ip, hostname, aliases and comment" do
 
     before do
       # Just playing with a few different delimiters
       @testline = "127.0.0.1\t   host  alias1\talias2   alias3   #   A comment with a #-char"
     end
 
     it "should parse the ip from the first field" do
       @provider.parse_line(@testline)[:ip].should == "127.0.0.1"
     end
 
     it "should parse the hostname from the second field" do
       @provider.parse_line(@testline)[:name].should == "host"
     end
 
     it "should parse all host_aliases from the third field" do
       @provider.parse_line(@testline)[:host_aliases].should == 'alias1 alias2 alias3'
     end
 
     it "should parse the comment after the first '#' character" do
       @provider.parse_line(@testline)[:comment].should == 'A comment with a #-char'
     end
 
   end
 
   describe "when operating on /etc/hosts like files" do
     it_should_behave_like "all parsedfile providers",
       provider_class, my_fixtures('valid*')
 
     it "should be able to generate a simple hostfile entry" do
       host = mkhost(
         :name   => 'localhost',
         :ip     => '127.0.0.1',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost\n"
     end
 
     it "should be able to generate an entry with one alias" do
       host = mkhost(
         :name   => 'localhost.localdomain',
         :ip     => '127.0.0.1',
         :host_aliases => 'localhost',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost.localdomain\tlocalhost\n"
     end
 
     it "should be able to generate an entry with more than one alias" do
       host = mkhost(
         :name       => 'host',
         :ip         => '192.0.0.1',
         :host_aliases => [ 'a1','a2','a3','a4' ],
         :ensure     => :present
       )
       genhost(host).should == "192.0.0.1\thost\ta1 a2 a3 a4\n"
     end
 
     it "should be able to generate a simple hostfile entry with comments" do
       host = mkhost(
         :name    => 'localhost',
         :ip      => '127.0.0.1',
         :comment => 'Bazinga!',
         :ensure  => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost\t# Bazinga!\n"
     end
 
     it "should be able to generate an entry with one alias and a comment" do
       host = mkhost(
         :name   => 'localhost.localdomain',
         :ip     => '127.0.0.1',
         :host_aliases => 'localhost',
         :comment => 'Bazinga!',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost.localdomain\tlocalhost\t# Bazinga!\n"
     end
 
     it "should be able to generate an entry with more than one alias and a comment" do
       host = mkhost(
         :name         => 'host',
         :ip           => '192.0.0.1',
         :host_aliases => [ 'a1','a2','a3','a4' ],
         :comment      => 'Bazinga!',
         :ensure       => :present
       )
       genhost(host).should == "192.0.0.1\thost\ta1 a2 a3 a4\t# Bazinga!\n"
     end
 
   end
 
 end
diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index e812e3359..c86525707 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -1,289 +1,289 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
 
-describe provider_class do
+describe provider_class, :fails_on_windows => true do
 
   before :each do
     @mount_class = Puppet::Type.type(:mount)
     @provider = @mount_class.provider(:parsed)
   end
 
   # LAK:FIXME I can't mock Facter because this test happens at parse-time.
   it "should default to /etc/vfstab on Solaris" do
     pending "This test only works on Solaris" unless Facter.value(:operatingsystem) == 'Solaris'
     Puppet::Type.type(:mount).provider(:parsed).default_target.should == '/etc/vfstab'
   end
 
   it "should default to /etc/fstab on anything else" do
     pending "This test does not work on Solaris" if Facter.value(:operatingsystem) == 'Solaris'
     Puppet::Type.type(:mount).provider(:parsed).default_target.should == '/etc/fstab'
   end
 
   describe "when parsing a line" do
 
     it "should not crash on incomplete lines in fstab" do
       parse = @provider.parse <<-FSTAB
 /dev/incomplete
 /dev/device       name
 FSTAB
       lambda{ @provider.to_line(parse[0]) }.should_not raise_error
     end
 
 #   it_should_behave_like "all parsedfile providers",
 #     provider_class, my_fixtures('*.fstab')
 
     describe "on Solaris", :if => Facter.value(:operatingsystem) == 'Solaris', :'fails_on_ruby_1.9.2' => true do
 
       before :each do
         @example_line = "/dev/dsk/c0d0s0 /dev/rdsk/c0d0s0 \t\t    /  \t    ufs     1 no\t-"
       end
 
       it "should extract device from the first field" do
         @provider.parse_line(@example_line)[:device].should == '/dev/dsk/c0d0s0'
       end
 
       it "should extract blockdevice from second field" do
         @provider.parse_line(@example_line)[:blockdevice].should == "/dev/rdsk/c0d0s0"
       end
 
       it "should extract name from third field" do
         @provider.parse_line(@example_line)[:name].should == "/"
       end
 
       it "should extract fstype from fourth field" do
         @provider.parse_line(@example_line)[:fstype].should == "ufs"
       end
 
       it "should extract pass from fifth field" do
         @provider.parse_line(@example_line)[:pass].should == "1"
       end
 
       it "should extract atboot from sixth field" do
         @provider.parse_line(@example_line)[:atboot].should == "no"
       end
 
       it "should extract options from seventh field" do
         @provider.parse_line(@example_line)[:options].should == "-"
       end
 
     end
 
     describe "on other platforms than Solaris", :if => Facter.value(:operatingsystem) != 'Solaris' do
 
       before :each do
         @example_line = "/dev/vg00/lv01\t/spare   \t  \t   ext3    defaults\t1 2"
       end
 
       it "should extract device from the first field" do
         @provider.parse_line(@example_line)[:device].should == '/dev/vg00/lv01'
       end
 
       it "should extract name from second field" do
         @provider.parse_line(@example_line)[:name].should == "/spare"
       end
 
       it "should extract fstype from third field" do
         @provider.parse_line(@example_line)[:fstype].should == "ext3"
       end
 
       it "should extract options from fourth field" do
         @provider.parse_line(@example_line)[:options].should == "defaults"
       end
 
       it "should extract dump from fifth field" do
         @provider.parse_line(@example_line)[:dump].should == "1"
       end
 
       it "should extract options from sixth field" do
         @provider.parse_line(@example_line)[:pass].should == "2"
       end
 
     end
 
   end
 
   describe "mountinstances" do
     it "should get name from mountoutput found on Solaris" do
       Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('solaris.mount')))
       mounts = @provider.mountinstances
       mounts.size.should == 6
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/proc', :mounted => :yes }
       mounts[2].should == { :name => '/etc/mnttab', :mounted => :yes }
       mounts[3].should == { :name => '/tmp', :mounted => :yes }
       mounts[4].should == { :name => '/export/home', :mounted => :yes }
       mounts[5].should == { :name => '/ghost', :mounted => :yes }
     end
 
     it "should get name from mountoutput found on HP-UX" do
       Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('hpux.mount')))
       mounts = @provider.mountinstances
       mounts.size.should == 17
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/devices', :mounted => :yes }
       mounts[2].should == { :name => '/dev', :mounted => :yes }
       mounts[3].should == { :name => '/system/contract', :mounted => :yes }
       mounts[4].should == { :name => '/proc', :mounted => :yes }
       mounts[5].should == { :name => '/etc/mnttab', :mounted => :yes }
       mounts[6].should == { :name => '/etc/svc/volatile', :mounted => :yes }
       mounts[7].should == { :name => '/system/object', :mounted => :yes }
       mounts[8].should == { :name => '/etc/dfs/sharetab', :mounted => :yes }
       mounts[9].should == { :name => '/lib/libc.so.1', :mounted => :yes }
       mounts[10].should == { :name => '/dev/fd', :mounted => :yes }
       mounts[11].should == { :name => '/tmp', :mounted => :yes }
       mounts[12].should == { :name => '/var/run', :mounted => :yes }
       mounts[13].should == { :name => '/export', :mounted => :yes }
       mounts[14].should == { :name => '/export/home', :mounted => :yes }
       mounts[15].should == { :name => '/rpool', :mounted => :yes }
       mounts[16].should == { :name => '/ghost', :mounted => :yes }
     end
 
     it "should get name from mountoutput found on Darwin" do
       Facter.stubs(:value).with(:operatingsystem).returns 'Darwin'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('darwin.mount')))
       mounts = @provider.mountinstances
       mounts.size.should == 6
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/dev', :mounted => :yes }
       mounts[2].should == { :name => '/net', :mounted => :yes }
       mounts[3].should == { :name => '/home', :mounted => :yes }
       mounts[4].should == { :name => '/usr', :mounted => :yes }
       mounts[5].should == { :name => '/ghost', :mounted => :yes }
     end
 
     it "should get name from mountoutput found on Linux" do
       Facter.stubs(:value).with(:operatingsystem).returns 'Gentoo'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('linux.mount')))
       mounts = @provider.mountinstances
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/lib64/rc/init.d', :mounted => :yes }
       mounts[2].should == { :name => '/sys', :mounted => :yes }
       mounts[3].should == { :name => '/usr/portage', :mounted => :yes }
       mounts[4].should == { :name => '/ghost', :mounted => :yes }
     end
 
     it "should get name from mountoutput found on AIX" do
       Facter.stubs(:value).with(:operatingsystem).returns 'AIX'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
       mounts = @provider.mountinstances
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/tmp', :mounted => :yes }
       mounts[2].should == { :name => '/home', :mounted => :yes }
       mounts[3].should == { :name => '/usr', :mounted => :yes }
       mounts[4].should == { :name => '/usr/code', :mounted => :yes }
     end
 
     it "should raise an error if a line is not understandable" do
       @provider.stubs(:mountcmd).returns("bazinga!")
       lambda { @provider.mountinstances }.should raise_error Puppet::Error
     end
 
   end
 
   it "should support AIX's paragraph based /etc/filesystems"
 
   my_fixtures('*.fstab').each do |fstab|
     platform = File.basename(fstab, '.fstab')
 
     describe "when calling instances on #{platform}" do
       before :each do
         if Facter[:operatingsystem] == "Solaris" then
           platform == 'solaris' or
             pending "We need to stub the operatingsystem fact at load time, but can't"
         else
           platform != 'solaris' or
             pending "We need to stub the operatingsystem fact at load time, but can't"
         end
 
         # Stub the mount output to our fixture.
         begin
           mount = my_fixture(platform + '.mount')
           @provider.stubs(:mountcmd).returns File.read(mount)
         rescue
           pending "is #{platform}.mount missing at this point?"
         end
 
         # Note: we have to stub default_target before creating resources
         # because it is used by Puppet::Type::Mount.new to populate the
         # :target property.
         @provider.stubs(:default_target).returns fstab
         @retrieve = @provider.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
       end
 
       # Following mountpoint are present in all fstabs/mountoutputs
       it "should include unmounted resources" do
         @retrieve.should include(:name => '/', :ensure => :mounted)
       end
 
       it "should include mounted resources" do
         @retrieve.should include(:name => '/boot', :ensure => :unmounted)
       end
 
       it "should include ghost resources" do
         @retrieve.should include(:name => '/ghost', :ensure => :ghost)
       end
 
     end
 
     describe "when prefetching on #{platform}" do
       before :each do
         if Facter[:operatingsystem] == "Solaris" then
           platform == 'solaris' or
             pending "We need to stub the operatingsystem fact at load time, but can't"
         else
           platform != 'solaris' or
             pending "We need to stub the operatingsystem fact at load time, but can't"
         end
 
         # Stub the mount output to our fixture.
         begin
           mount = my_fixture(platform + '.mount')
           @provider.stubs(:mountcmd).returns File.read(mount)
         rescue
           pending "is #{platform}.mount missing at this point?"
         end
 
         # Note: we have to stub default_target before creating resources
         # because it is used by Puppet::Type::Mount.new to populate the
         # :target property.
         @provider.stubs(:default_target).returns fstab
 
         @res_ghost = Puppet::Type::Mount.new(:name => '/ghost')    # in no fake fstab
         @res_mounted = Puppet::Type::Mount.new(:name => '/')       # in every fake fstab
         @res_unmounted = Puppet::Type::Mount.new(:name => '/boot') # in every fake fstab
         @res_absent = Puppet::Type::Mount.new(:name => '/absent')  # in no fake fstab
 
         # Simulate transaction.rb:prefetch
         @resource_hash = {}
         [@res_ghost, @res_mounted, @res_unmounted, @res_absent].each do |resource|
           @resource_hash[resource.name] = resource
         end
       end
 
       it "should set :ensure to :unmounted if found in fstab but not mounted" do
         @provider.prefetch(@resource_hash)
         @res_unmounted.provider.get(:ensure).should == :unmounted
       end
 
       it "should set :ensure to :ghost if not found in fstab but mounted" do
         @provider.prefetch(@resource_hash)
         @res_ghost.provider.get(:ensure).should == :ghost
       end
 
       it "should set :ensure to :mounted if found in fstab and mounted" do
         @provider.prefetch(@resource_hash)
         @res_mounted.provider.get(:ensure).should == :mounted
       end
 
       it "should set :ensure to :absent if not found in fstab and not mounted" do
         @provider.prefetch(@resource_hash)
         @res_absent.provider.get(:ensure).should == :absent
       end
     end
   end
 end
diff --git a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
index bd5e55a9e..8a7fe755c 100755
--- a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
+++ b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
@@ -1,200 +1,200 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 require 'puppet_spec/files'
 
 provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
 
 describe provider_class do
   include PuppetSpec::Files
 
   before :each do
     @keyfile = tmpfile('authorized_keys')
     @provider_class = provider_class
     @provider_class.initvars
     @provider_class.any_instance.stubs(:target).returns @keyfile
     @user = 'random_bob'
     Puppet::Util.stubs(:uid).with(@user).returns 12345
   end
 
   def mkkey(args)
     args[:target] = @keyfile
     args[:user]   = @user
     resource = Puppet::Type.type(:ssh_authorized_key).new(args)
     key = @provider_class.new(resource)
     args.each do |p,v|
       key.send(p.to_s + "=", v)
     end
     key
   end
 
   def genkey(key)
     @provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     File.stubs(:chown)
     File.stubs(:chmod)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
     key.flush
     @provider_class.target_object(@keyfile).read
   end
 
   it_should_behave_like "all parsedfile providers", provider_class
 
   it "should be able to generate a basic authorized_keys file" do
 
     key = mkkey(:name    => "Just_Testing",
                 :key     => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
                 :type    => "ssh-dss",
                 :ensure  => :present,
                 :options => [:absent]
               )
 
     genkey(key).should == "ssh-dss AAAAfsfddsjldjgksdflgkjsfdlgkj Just_Testing\n"
   end
 
   it "should be able to generate a authorized_keys file with options" do
 
     key = mkkey(:name    => "root@localhost",
                 :key     => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
                 :type    => "ssh-rsa",
                 :ensure  => :present,
                 :options => ['from="192.168.1.1"', "no-pty", "no-X11-forwarding"]
                 )
 
     genkey(key).should == "from=\"192.168.1.1\",no-pty,no-X11-forwarding ssh-rsa AAAAfsfddsjldjgksdflgkjsfdlgkj root@localhost\n"
   end
 
   it "should be able to parse options containing commas via its parse_options method" do
     options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
     optionstr = options.join(", ")
 
     @provider_class.parse_options(optionstr).should == options
   end
 
   it "should use '' as name for entries that lack a comment" do
     line = "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAut8aOSxenjOqF527dlsdHWV4MNoAsX14l9M297+SQXaQ5Z3BedIxZaoQthkDALlV/25A1COELrg9J2MqJNQc8Xe9XQOIkBQWWinUlD/BXwoOTWEy8C8zSZPHZ3getMMNhGTBO+q/O+qiJx3y5cA4MTbw2zSxukfWC87qWwcZ64UUlegIM056vPsdZWFclS9hsROVEa57YUMrehQ1EGxT4Z5j6zIopufGFiAPjZigq/vqgcAqhAKP6yu4/gwO6S9tatBeEjZ8fafvj1pmvvIplZeMr96gHE7xS3pEEQqnB3nd4RY7AF6j9kFixnsytAUO7STPh/M3pLiVQBN89TvWPQ=="
 
     @provider_class.parse(line)[0][:name].should == ""
   end
 end
 
 describe provider_class do
   before :each do
     @resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :user => "random_bob")
 
     @provider = provider_class.new(@resource)
     provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
 
     provider_class.initvars
   end
 
   describe "when flushing" do
     before :each do
       # Stub file and directory operations
       Dir.stubs(:mkdir)
       File.stubs(:chmod)
       File.stubs(:chown)
     end
 
     describe "and both a user and a target have been specified" do
       before :each do
         Puppet::Util.stubs(:uid).with("random_bob").returns 12345
         @resource[:user] = "random_bob"
         target = "/tmp/.ssh_dir/place_to_put_authorized_keys"
         @resource[:target] = target
       end
 
       it "should create the directory" do
         File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
         Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0700)
         @provider.flush
       end
 
       it "should chown the directory to the user" do
         uid = Puppet::Util.uid("random_bob")
         File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir")
         @provider.flush
       end
 
       it "should chown the key file to the user" do
         uid = Puppet::Util.uid("random_bob")
         File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider.flush
       end
 
       it "should chmod the key file to 0600" do
         File.expects(:chmod).with(0600, "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider.flush
       end
     end
 
-    describe "and a user has been specified with no target" do
+    describe "and a user has been specified with no target", :fails_on_windows => true do
       before :each do
         @resource[:user] = "nobody"
         #
         # I'd like to use random_bob here and something like
         #
         #    File.stubs(:expand_path).with("~random_bob/.ssh").returns "/users/r/random_bob/.ssh"
         #
         # but mocha objects strenuously to stubbing File.expand_path
         # so I'm left with using nobody.
         @dir = File.expand_path("~nobody/.ssh")
       end
 
       it "should create the directory if it doesn't exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).with(@dir,0700)
         @provider.flush
       end
 
       it "should not create or chown the directory if it already exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).never
         @provider.flush
       end
 
       it "should chown the directory to the user if it creates it" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.stubs(:mkdir).with(@dir,0700)
         uid = Puppet::Util.uid("nobody")
         File.expects(:chown).with(uid, nil, @dir)
         @provider.flush
       end
 
       it "should not create or chown the directory if it already exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).never
         File.expects(:chown).never
         @provider.flush
       end
 
       it "should chown the key file to the user" do
         uid = Puppet::Util.uid("nobody")
         File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh/authorized_keys"))
         @provider.flush
       end
 
       it "should chmod the key file to 0600" do
         File.expects(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
         @provider.flush
       end
     end
 
     describe "and a target has been specified with no user" do
       it "should raise an error" do
         @resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :target => "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider = provider_class.new(@resource)
 
         proc { @provider.flush }.should raise_error
       end
     end
 
-    describe "and a invalid user has been specified with no target" do
+    describe "and a invalid user has been specified with no target", :fails_on_windows => true do
       it "should catch an exception and raise a Puppet error" do
         @resource[:user] = "thisusershouldnotexist"
 
         lambda { @provider.flush }.should raise_error(Puppet::Error)
       end
     end
   end
 end
diff --git a/spec/unit/provider/user/user_role_add_spec.rb b/spec/unit/provider/user/user_role_add_spec.rb
index 5f2fc306e..c44fc5a65 100755
--- a/spec/unit/provider/user/user_role_add_spec.rb
+++ b/spec/unit/provider/user/user_role_add_spec.rb
@@ -1,266 +1,266 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:user).provider(:user_role_add)
 
-describe provider_class do
+describe provider_class, :fails_on_windows => true do
   before do
     @resource = stub("resource", :name => "myuser", :managehome? => nil)
     @resource.stubs(:should).returns "fakeval"
     @resource.stubs(:[]).returns "fakeval"
     @resource.stubs(:allowdupe?).returns false
     @provider = provider_class.new(@resource)
   end
 
   describe "when calling command" do
     before do
       klass = stub("provider")
       klass.stubs(:command).with(:foo).returns("userfoo")
       klass.stubs(:command).with(:role_foo).returns("rolefoo")
       @provider.stubs(:class).returns(klass)
     end
 
     it "should use the command if not a role and ensure!=role" do
       @provider.stubs(:is_role?).returns(false)
       @provider.stubs(:exists?).returns(false)
       @resource.stubs(:[]).with(:ensure).returns(:present)
       @provider.command(:foo).should == "userfoo"
     end
 
     it "should use the role command when a role" do
       @provider.stubs(:is_role?).returns(true)
       @provider.command(:foo).should == "rolefoo"
     end
 
     it "should use the role command when !exists and ensure=role" do
       @provider.stubs(:is_role?).returns(false)
       @provider.stubs(:exists?).returns(false)
       @resource.stubs(:[]).with(:ensure).returns(:role)
       @provider.command(:foo).should == "rolefoo"
     end
   end
 
   describe "when calling transition", :'fails_on_ruby_1.9.2' => true do
     it "should return the type set to whatever is passed in" do
       @provider.expects(:command).with(:modify).returns("foomod")
       @provider.transition("bar").include?("type=bar")
     end
   end
 
   describe "when calling create" do
     before do
       @provider.stubs(:password=)
     end
 
     it "should use the add command when the user is not a role" do
       @provider.stubs(:is_role?).returns(false)
       @provider.expects(:addcmd).returns("useradd")
       @provider.expects(:run).at_least_once
       @provider.create
     end
 
     it "should use transition(normal) when the user is a role" do
       @provider.stubs(:is_role?).returns(true)
       @provider.expects(:transition).with("normal")
       @provider.expects(:run)
       @provider.create
     end
 
     it "should set password age rules" do
       @resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :provider => :user_role_add
       @provider = provider_class.new(@resource)
       @provider.stubs(:user_attributes)
       @provider.stubs(:execute)
       @provider.expects(:execute).with { |cmd, *args| args == ["-n", 5, "-x", 10, "myuser"] }
       @provider.create
     end
   end
 
   describe "when calling destroy" do
     it "should use the delete command if the user exists and is not a role" do
       @provider.stubs(:exists?).returns(true)
       @provider.stubs(:is_role?).returns(false)
       @provider.expects(:deletecmd)
       @provider.expects(:run)
       @provider.destroy
     end
 
     it "should use the delete command if the user is a role" do
       @provider.stubs(:exists?).returns(true)
       @provider.stubs(:is_role?).returns(true)
       @provider.expects(:deletecmd)
       @provider.expects(:run)
       @provider.destroy
     end
   end
 
   describe "when calling create_role" do
     it "should use the transition(role) if the user exists" do
       @provider.stubs(:exists?).returns(true)
       @provider.stubs(:is_role?).returns(false)
       @provider.expects(:transition).with("role")
       @provider.expects(:run)
       @provider.create_role
     end
 
     it "should use the add command when role doesn't exists" do
       @provider.stubs(:exists?).returns(false)
       @provider.expects(:addcmd)
       @provider.expects(:run)
       @provider.create_role
     end
   end
 
   describe "when allow duplicate is enabled" do
     before do
       @resource.expects(:allowdupe?).returns true
       @resource.stubs(:system?)
       @provider.stubs(:is_role?).returns(false)
       @provider.stubs(:execute)
       @provider.expects(:execute).with { |args| args.include?("-o") }
     end
 
     it "should add -o when the user is being created", :'fails_on_ruby_1.9.2' => true do
       @provider.stubs(:password=)
       @provider.create
     end
 
     it "should add -o when the uid is being modified" do
       @provider.uid = 150
     end
   end
 
   [:roles, :auths, :profiles].each do |val|
     describe "when getting #{val}" do
       it "should get the user_attributes" do
         @provider.expects(:user_attributes)
         @provider.send(val)
       end
 
       it "should get the #{val} attribute" do
         attributes = mock("attributes")
         attributes.expects(:[]).with(val)
         @provider.stubs(:user_attributes).returns(attributes)
         @provider.send(val)
       end
     end
   end
 
   describe "when getting the keys" do
     it "should get the user_attributes" do
       @provider.expects(:user_attributes)
       @provider.keys
     end
 
     it "should call removed_managed_attributes" do
       @provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
       @provider.expects(:remove_managed_attributes)
       @provider.keys
     end
 
     it "should removed managed attribute (type, auths, roles, etc)" do
       @provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
       @provider.keys.should == { :foo => "something" }
     end
   end
 
   describe "when adding properties" do
     it "should call build_keys_cmd" do
       @resource.stubs(:should).returns ""
       @resource.expects(:should).with(:keys).returns({ :foo => "bar" })
       @provider.expects(:build_keys_cmd).returns([])
       @provider.add_properties
     end
 
     it "should add the elements of the keys hash to an array" do
       @resource.stubs(:should).returns ""
       @resource.expects(:should).with(:keys).returns({ :foo => "bar"})
       @provider.add_properties.must == ["-K", "foo=bar"]
     end
   end
 
   describe "when calling build_keys_cmd" do
     it "should build cmd array with keypairs seperated by -K ending with user" do
       @provider.build_keys_cmd({"foo" => "bar", "baz" => "boo"}).should.eql? ["-K", "foo=bar", "-K", "baz=boo"]
     end
   end
 
   describe "when setting the keys" do
     before do
       @provider.stubs(:is_role?).returns(false)
     end
 
     it "should run a command" do
       @provider.expects(:run)
       @provider.keys=({})
     end
 
     it "should build the command" do
       @resource.stubs(:[]).with(:name).returns("someuser")
       @provider.stubs(:command).returns("usermod")
       @provider.expects(:build_keys_cmd).returns(["-K", "foo=bar"])
       @provider.expects(:run).with(["usermod", "-K", "foo=bar", "someuser"], "modify attribute key pairs")
       @provider.keys=({})
     end
   end
 
   describe "when getting the hashed password" do
     before do
       @array = mock "array"
     end
 
     it "should readlines of /etc/shadow" do
       File.expects(:readlines).with("/etc/shadow").returns([])
       @provider.password
     end
 
     it "should reject anything that doesn't start with alpha numerics" do
       @array.expects(:reject).returns([])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
       @provider.password
     end
 
     it "should collect splitting on ':'" do
       @array.stubs(:reject).returns(@array)
       @array.expects(:collect).returns([])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
       @provider.password
     end
 
     it "should find the matching user" do
       @resource.stubs(:[]).with(:name).returns("username")
       @array.stubs(:reject).returns(@array)
       @array.stubs(:collect).returns([["username", "hashedpassword"], ["someoneelse", "theirpassword"]])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
       @provider.password.must == "hashedpassword"
     end
 
     it "should get the right password" do
       @resource.stubs(:[]).with(:name).returns("username")
       File.stubs(:readlines).with("/etc/shadow").returns(["#comment", "   nonsense", "  ", "username:hashedpassword:stuff:foo:bar:::", "other:pword:yay:::"])
       @provider.password.must == "hashedpassword"
     end
   end
 
   describe "when setting the password" do
     #how can you mock these blocks up?
     it "should open /etc/shadow for reading and /etc/shadow_tmp for writing" do
       File.expects(:open).with("/etc/shadow", "r")
       File.stubs(:rename)
       @provider.password=("hashedpassword")
     end
 
     it "should rename the /etc/shadow_tmp to /etc/shadow" do
       File.stubs(:open).with("/etc/shadow", "r")
       File.expects(:rename).with("/etc/shadow_tmp", "/etc/shadow")
       @provider.password=("hashedpassword")
     end
   end
 
   describe "#shadow_entry" do
     it "should return the line for the right user" do
       File.stubs(:readlines).returns(["someuser:!:10:5:20:7:1::\n", "fakeval:*:20:10:30:7:2::\n", "testuser:*:30:15:40:7:3::\n"])
       @provider.shadow_entry.should == ["fakeval", "*", "20", "10", "30", "7", "2"]
     end
   end
 end
diff --git a/spec/unit/provider/user/useradd_spec.rb b/spec/unit/provider/user/useradd_spec.rb
index 724fc12c0..4265ee3a0 100755
--- a/spec/unit/provider/user/useradd_spec.rb
+++ b/spec/unit/provider/user/useradd_spec.rb
@@ -1,215 +1,215 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:user).provider(:useradd)
 
-describe provider_class do
+describe provider_class, :fails_on_windows => true do
   before do
     @resource = stub("resource", :name => "myuser", :managehome? => nil)
     @resource.stubs(:should).returns "fakeval"
     @resource.stubs(:[]).returns "fakeval"
     @provider = provider_class.new(@resource)
   end
 
   # #1360
   it "should add -o when allowdupe is enabled and the user is being created" do
     @resource.expects(:allowdupe?).returns true
     @resource.expects(:system?).returns true
     @provider.stubs(:execute)
     @provider.expects(:execute).with { |args| args.include?("-o") }
     @provider.create
   end
 
   it "should add -o when allowdupe is enabled and the uid is being modified" do
     @resource.expects(:allowdupe?).returns true
     @provider.expects(:execute).with { |args| args.include?("-o") }
 
     @provider.uid = 150
   end
 
   it "should add -r when system is enabled" do
     @resource.expects(:allowdupe?).returns true
     @resource.expects(:system?).returns true
     @provider.stubs(:execute)
     @provider.expects(:execute).with { |args| args.include?("-r") }
     @provider.create
   end
 
   it "should set password age rules" do
     provider_class.has_feature :manages_password_age
     @resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :provider => :useradd
     @provider = provider_class.new(@resource)
     @provider.stubs(:execute)
     @provider.expects(:execute).with { |cmd, *args| args == ["-m", 5, "-M", 10, "myuser"] }
     @provider.create
   end
 
   describe "when checking to add allow dup" do
     it "should check allow dup" do
       @resource.expects(:allowdupe?)
       @provider.check_allow_dup
     end
 
     it "should return an array with a flag if dup is allowed" do
       @resource.stubs(:allowdupe?).returns true
       @provider.check_allow_dup.must == ["-o"]
     end
 
     it "should return an empty array if no dup is allowed" do
       @resource.stubs(:allowdupe?).returns false
       @provider.check_allow_dup.must == []
     end
   end
 
   describe "when checking to add system users" do
     it "should check system users" do
       @resource.expects(:system?)
       @provider.check_system_users
     end
 
     it "should return an array with a flag if it's a system user" do
       @resource.stubs(:system?).returns true
       @provider.check_system_users.must == ["-r"]
     end
 
     it "should return an empty array if it's not a system user" do
       @resource.stubs(:system?).returns false
       @provider.check_system_users.must == []
     end
   end
 
   describe "when checking manage home" do
     it "should check manage home" do
       @resource.expects(:managehome?)
       @provider.check_manage_home
     end
 
     it "should return an array with -m flag if home is managed" do
       @resource.stubs(:managehome?).returns true
       @provider.check_manage_home.must == ["-m"]
     end
 
     it "should return an array with -M if home is not managed and on Redhat" do
       Facter.stubs(:value).with("operatingsystem").returns("RedHat")
       @resource.stubs(:managehome?).returns false
       @provider.check_manage_home.must == ["-M"]
     end
 
     it "should return an empty array if home is not managed and not on Redhat" do
       Facter.stubs(:value).with("operatingsystem").returns("some OS")
       @resource.stubs(:managehome?).returns false
       @provider.check_manage_home.must == []
     end
   end
 
   describe "when adding properties" do
     it "should get the valid properties"
     it "should not add the ensure property"
     it "should add the flag and value to an array"
     it "should return and array of flags and values"
   end
 
   describe "when calling addcmd" do
     before do
       @resource.stubs(:allowdupe?).returns true
       @resource.stubs(:managehome?).returns true
       @resource.stubs(:system?).returns true
     end
 
     it "should call command with :add" do
       @provider.expects(:command).with(:add)
       @provider.addcmd
     end
 
     it "should add properties" do
       @provider.expects(:add_properties).returns([])
       @provider.addcmd
     end
 
     it "should check and add if dup allowed" do
       @provider.expects(:check_allow_dup).returns([])
       @provider.addcmd
     end
 
     it "should check and add if home is managed" do
       @provider.expects(:check_manage_home).returns([])
       @provider.addcmd
     end
 
     it "should add the resource :name" do
       @resource.expects(:[]).with(:name)
       @provider.addcmd
     end
 
     it "should return an array with -r if system? is true" do
       resource = Puppet::Type.type(:user).new( :name => "bob", :system => true)
 
       provider_class.new( resource ).addcmd.should include("-r")
     end
 
     it "should return an array without -r if system? is false" do
       resource = Puppet::Type.type(:user).new( :name => "bob", :system => false)
 
       provider_class.new( resource ).addcmd.should_not include("-r")
     end
 
     it "should return an array with full command" do
       @provider.stubs(:command).with(:add).returns("useradd")
       @provider.stubs(:add_properties).returns(["-G", "somegroup"])
       @resource.stubs(:[]).with(:name).returns("someuser")
       @resource.stubs(:[]).with(:expiry).returns("somedate")
       @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", '-e somedate', "-r", "someuser"]
     end
 
     it "should return an array without -e if expiry is undefined full command" do
       @provider.stubs(:command).with(:add).returns("useradd")
       @provider.stubs(:add_properties).returns(["-G", "somegroup"])
       @resource.stubs(:[]).with(:name).returns("someuser")
       @resource.stubs(:[]).with(:expiry).returns nil
       @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", "-r", "someuser"]
     end
   end
 
   describe "when calling passcmd" do
     before do
       @resource.stubs(:allowdupe?).returns true
       @resource.stubs(:managehome?).returns true
       @resource.stubs(:system?).returns true
     end
 
     it "should call command with :pass" do
       @provider.expects(:command).with(:password)
       @provider.passcmd
     end
 
     it "should return nil if neither min nor max is set" do
       @resource.stubs(:should).with(:password_min_age).returns nil
       @resource.stubs(:should).with(:password_max_age).returns nil
       @provider.passcmd.must == nil
     end
 
     it "should return a chage command array with -m <value> and the user name if password_min_age is set" do
       @provider.stubs(:command).with(:password).returns("chage")
       @resource.stubs(:[]).with(:name).returns("someuser")
       @resource.stubs(:should).with(:password_min_age).returns 123
       @resource.stubs(:should).with(:password_max_age).returns nil
       @provider.passcmd.must == ['chage','-m',123,'someuser']
     end
 
     it "should return a chage command array with -M <value> if password_max_age is set" do
       @provider.stubs(:command).with(:password).returns("chage")
       @resource.stubs(:[]).with(:name).returns("someuser")
       @resource.stubs(:should).with(:password_min_age).returns nil
       @resource.stubs(:should).with(:password_max_age).returns 999
       @provider.passcmd.must == ['chage','-M',999,'someuser']
     end
 
     it "should return a chage command array with -M <value> -m <value> if both password_min_age and password_max_age are set" do
       @provider.stubs(:command).with(:password).returns("chage")
       @resource.stubs(:[]).with(:name).returns("someuser")
       @resource.stubs(:should).with(:password_min_age).returns 123
       @resource.stubs(:should).with(:password_max_age).returns 999
       @provider.passcmd.must == ['chage','-m',123,'-M',999,'someuser']
     end
   end
 end
diff --git a/spec/unit/resource/catalog_spec.rb b/spec/unit/resource/catalog_spec.rb
index f8f765854..7d513fdc6 100755
--- a/spec/unit/resource/catalog_spec.rb
+++ b/spec/unit/resource/catalog_spec.rb
@@ -1,1110 +1,1110 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Resource::Catalog, "when compiling" do
   include PuppetSpec::Files
 
   before do
     @basepath = make_absolute("/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_not be
     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 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 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 non-isomorphic resources whose names do not match their titles" do
+    it "should not create aliases for non-isomorphic resources whose names do not match their titles", :fails_on_windows => true  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 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
 
     describe "when adding resources with multiple namevars" do
       before :each do
         Puppet::Type.newtype(:multiple) do
           newparam(:color, :namevar => true)
           newparam(:designation, :namevar => true)
 
           def self.title_patterns
             [ [
                 /^(\w+) (\w+)$/,
                 [
                   [:color,  lambda{|x| x}],
                   [:designation, lambda{|x| x}]
                 ]
             ] ]
           end
         end
       end
 
       it "should add an alias using the uniqueness key" do
         @resource = Puppet::Type.type(:multiple).new(:title => "some resource", :color => "red", :designation => "5")
 
         @catalog.add_resource(@resource)
         @catalog.resource(:multiple, "some resource").must == @resource
         @catalog.resource("Multiple[some resource]").must == @resource
         @catalog.resource("Multiple[red 5]").must == @resource
       end
 
       it "should conflict with a resource with the same uniqueness key" do
         @resource = Puppet::Type.type(:multiple).new(:title => "some resource", :color => "red", :designation => "5")
         @other    = Puppet::Type.type(:multiple).new(:title => "another resource", :color => "red", :designation => "5")
 
         @catalog.add_resource(@resource)
         expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias Multiple\[another resource\] to \["red", "5"\].*resource \["Multiple", "red", "5"\] already defined/)
       end
 
       it "should conflict when its uniqueness key matches another resource's title" do
         @resource = Puppet::Type.type(:file).new(:title => "/tmp/foo")
         @other    = Puppet::Type.type(:file).new(:title => "another file", :path => "/tmp/foo")
 
         @catalog.add_resource(@resource)
         expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias File\[another file\] to \["\/tmp\/foo"\].*resource \["File", "\/tmp\/foo"\] already defined/)
       end
 
       it "should conflict when its uniqueness key matches the uniqueness key derived from another resource's title" do
         @resource = Puppet::Type.type(:multiple).new(:title => "red leader")
         @other    = Puppet::Type.type(:multiple).new(:title => "another resource", :color => "red", :designation => "leader")
 
         @catalog.add_resource(@resource)
         expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias Multiple\[another resource\] to \["red", "leader"\].*resource \["Multiple", "red", "leader"\] already defined/)
       end
     end
   end
 
   describe "when applying" do
     before :each do
       @catalog = Puppet::Resource::Catalog.new("host")
 
       @transaction = Puppet::Transaction.new(@catalog)
       Puppet::Transaction.stubs(:new).returns(@transaction)
       @transaction.stubs(:evaluate)
       @transaction.stubs(:add_times)
       @transaction.stubs(:for_network_device=)
 
       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.path_between(@one, @two).should be
     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 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", :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.edges_between(one, two  )[0].expects(:to_pson_data_hash).returns "one_two_pson"
     @catalog.edges_between(two, three)[0].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", :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/ssl/host_spec.rb b/spec/unit/ssl/host_spec.rb
index c2d9690e6..e1680941f 100755
--- a/spec/unit/ssl/host_spec.rb
+++ b/spec/unit/ssl/host_spec.rb
@@ -1,793 +1,793 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/host'
 require 'puppet/sslcertificates'
 require 'puppet/sslcertificates/ca'
 
-describe Puppet::SSL::Host do
+describe Puppet::SSL::Host, :fails_on_windows => true do
   before do
     Puppet::SSL::Host.indirection.terminus_class = :file
     @host = Puppet::SSL::Host.new("myname")
   end
 
   after do
     # Cleaned out any cached localhost instance.
     Puppet::Util::Cacher.expire
     Puppet::SSL::Host.ca_location = :none
   end
 
   it "should use any provided name as its name" do
     @host.name.should == "myname"
   end
 
   it "should retrieve its public key from its private key" do
     realkey = mock 'realkey'
     key = stub 'key', :content => realkey
     Puppet::SSL::Key.indirection.stubs(:find).returns(key)
     pubkey = mock 'public_key'
     realkey.expects(:public_key).returns pubkey
 
     @host.public_key.should equal(pubkey)
   end
 
   it "should default to being a non-ca host" do
     @host.ca?.should be_false
   end
 
   it "should be a ca host if its name matches the CA_NAME" do
     Puppet::SSL::Host.stubs(:ca_name).returns "yayca"
     Puppet::SSL::Host.new("yayca").should be_ca
   end
 
   it "should have a method for determining the CA location" do
     Puppet::SSL::Host.should respond_to(:ca_location)
   end
 
   it "should have a method for specifying the CA location" do
     Puppet::SSL::Host.should respond_to(:ca_location=)
   end
 
   it "should have a method for retrieving the default ssl host" do
     Puppet::SSL::Host.should respond_to(:ca_location=)
   end
 
   it "should have a method for producing an instance to manage the local host's keys" do
     Puppet::SSL::Host.should respond_to(:localhost)
   end
 
   it "should generate the certificate for the localhost instance if no certificate is available" do
     host = stub 'host', :key => nil
     Puppet::SSL::Host.expects(:new).returns host
 
     host.expects(:certificate).returns nil
     host.expects(:generate)
 
     Puppet::SSL::Host.localhost.should equal(host)
   end
 
   it "should always read the key for the localhost instance in from disk" do
     host = stub 'host', :certificate => "eh"
     Puppet::SSL::Host.expects(:new).returns host
 
     host.expects(:key)
 
     Puppet::SSL::Host.localhost
   end
 
   it "should cache the localhost instance" do
     host = stub 'host', :certificate => "eh", :key => 'foo'
     Puppet::SSL::Host.expects(:new).once.returns host
 
     Puppet::SSL::Host.localhost.should == Puppet::SSL::Host.localhost
   end
 
   it "should be able to expire the cached instance" do
     one = stub 'host1', :certificate => "eh", :key => 'foo'
     two = stub 'host2', :certificate => "eh", :key => 'foo'
     Puppet::SSL::Host.expects(:new).times(2).returns(one).then.returns(two)
 
     Puppet::SSL::Host.localhost.should equal(one)
     Puppet::Util::Cacher.expire
     Puppet::SSL::Host.localhost.should equal(two)
   end
 
   it "should be able to verify its certificate matches its key" do
     Puppet::SSL::Host.new("foo").should respond_to(:certificate_matches_key?)
   end
 
   it "should consider the certificate invalid if it cannot find a key" do
     host = Puppet::SSL::Host.new("foo")
     host.expects(:key).returns nil
 
     host.should_not be_certificate_matches_key
   end
 
   it "should consider the certificate invalid if it cannot find a certificate" do
     host = Puppet::SSL::Host.new("foo")
     host.expects(:key).returns mock("key")
     host.expects(:certificate).returns nil
 
     host.should_not be_certificate_matches_key
   end
 
   it "should consider the certificate invalid if the SSL certificate's key verification fails" do
     host = Puppet::SSL::Host.new("foo")
 
     key = mock 'key', :content => "private_key"
     sslcert = mock 'sslcert'
     certificate = mock 'cert', :content => sslcert
 
     host.stubs(:key).returns key
     host.stubs(:certificate).returns certificate
 
     sslcert.expects(:check_private_key).with("private_key").returns false
 
     host.should_not be_certificate_matches_key
   end
 
   it "should consider the certificate valid if the SSL certificate's key verification succeeds" do
     host = Puppet::SSL::Host.new("foo")
 
     key = mock 'key', :content => "private_key"
     sslcert = mock 'sslcert'
     certificate = mock 'cert', :content => sslcert
 
     host.stubs(:key).returns key
     host.stubs(:certificate).returns certificate
 
     sslcert.expects(:check_private_key).with("private_key").returns true
 
     host.should be_certificate_matches_key
   end
 
   describe "when specifying the CA location" do
     it "should support the location ':local'" do
       lambda { Puppet::SSL::Host.ca_location = :local }.should_not raise_error
     end
 
     it "should support the location ':remote'" do
       lambda { Puppet::SSL::Host.ca_location = :remote }.should_not raise_error
     end
 
     it "should support the location ':none'" do
       lambda { Puppet::SSL::Host.ca_location = :none }.should_not raise_error
     end
 
     it "should support the location ':only'" do
       lambda { Puppet::SSL::Host.ca_location = :only }.should_not raise_error
     end
 
     it "should not support other modes" do
       lambda { Puppet::SSL::Host.ca_location = :whatever }.should raise_error(ArgumentError)
     end
 
     describe "as 'local'" do
       before do
         Puppet::SSL::Host.ca_location = :local
       end
 
       it "should set the cache class for Certificate, CertificateRevocationList, and CertificateRequest as :file" do
         Puppet::SSL::Certificate.indirection.cache_class.should == :file
         Puppet::SSL::CertificateRequest.indirection.cache_class.should == :file
         Puppet::SSL::CertificateRevocationList.indirection.cache_class.should == :file
       end
 
       it "should set the terminus class for Key and Host as :file" do
         Puppet::SSL::Key.indirection.terminus_class.should == :file
         Puppet::SSL::Host.indirection.terminus_class.should == :file
       end
 
       it "should set the terminus class for Certificate, CertificateRevocationList, and CertificateRequest as :ca" do
         Puppet::SSL::Certificate.indirection.terminus_class.should == :ca
         Puppet::SSL::CertificateRequest.indirection.terminus_class.should == :ca
         Puppet::SSL::CertificateRevocationList.indirection.terminus_class.should == :ca
       end
     end
 
     describe "as 'remote'" do
       before do
         Puppet::SSL::Host.ca_location = :remote
       end
 
       it "should set the cache class for Certificate, CertificateRevocationList, and CertificateRequest as :file" do
         Puppet::SSL::Certificate.indirection.cache_class.should == :file
         Puppet::SSL::CertificateRequest.indirection.cache_class.should == :file
         Puppet::SSL::CertificateRevocationList.indirection.cache_class.should == :file
       end
 
       it "should set the terminus class for Key as :file" do
         Puppet::SSL::Key.indirection.terminus_class.should == :file
       end
 
       it "should set the terminus class for Host, Certificate, CertificateRevocationList, and CertificateRequest as :rest" do
         Puppet::SSL::Host.indirection.terminus_class.should == :rest
         Puppet::SSL::Certificate.indirection.terminus_class.should == :rest
         Puppet::SSL::CertificateRequest.indirection.terminus_class.should == :rest
         Puppet::SSL::CertificateRevocationList.indirection.terminus_class.should == :rest
       end
     end
 
     describe "as 'only'" do
       before do
         Puppet::SSL::Host.ca_location = :only
       end
 
       it "should set the terminus class for Key, Certificate, CertificateRevocationList, and CertificateRequest as :ca" do
         Puppet::SSL::Key.indirection.terminus_class.should == :ca
         Puppet::SSL::Certificate.indirection.terminus_class.should == :ca
         Puppet::SSL::CertificateRequest.indirection.terminus_class.should == :ca
         Puppet::SSL::CertificateRevocationList.indirection.terminus_class.should == :ca
       end
 
       it "should set the cache class for Certificate, CertificateRevocationList, and CertificateRequest to nil" do
         Puppet::SSL::Certificate.indirection.cache_class.should be_nil
         Puppet::SSL::CertificateRequest.indirection.cache_class.should be_nil
         Puppet::SSL::CertificateRevocationList.indirection.cache_class.should be_nil
       end
 
       it "should set the terminus class for Host to :file" do
         Puppet::SSL::Host.indirection.terminus_class.should == :file
       end
     end
 
     describe "as 'none'" do
       before do
         Puppet::SSL::Host.ca_location = :none
       end
 
       it "should set the terminus class for Key, Certificate, CertificateRevocationList, and CertificateRequest as :file" do
         Puppet::SSL::Key.indirection.terminus_class.should == :file
         Puppet::SSL::Certificate.indirection.terminus_class.should == :file
         Puppet::SSL::CertificateRequest.indirection.terminus_class.should == :file
         Puppet::SSL::CertificateRevocationList.indirection.terminus_class.should == :file
       end
 
       it "should set the terminus class for Host to 'none'" do
         lambda { Puppet::SSL::Host.indirection.terminus_class }.should raise_error(Puppet::DevError)
       end
     end
   end
 
   it "should have a class method for destroying all files related to a given host" do
     Puppet::SSL::Host.should respond_to(:destroy)
   end
 
   describe "when destroying a host's SSL files" do
     before do
       Puppet::SSL::Key.indirection.stubs(:destroy).returns false
       Puppet::SSL::Certificate.indirection.stubs(:destroy).returns false
       Puppet::SSL::CertificateRequest.indirection.stubs(:destroy).returns false
     end
 
     it "should destroy its certificate, certificate request, and key" do
       Puppet::SSL::Key.indirection.expects(:destroy).with("myhost")
       Puppet::SSL::Certificate.indirection.expects(:destroy).with("myhost")
       Puppet::SSL::CertificateRequest.indirection.expects(:destroy).with("myhost")
 
       Puppet::SSL::Host.destroy("myhost")
     end
 
     it "should return true if any of the classes returned true" do
       Puppet::SSL::Certificate.indirection.expects(:destroy).with("myhost").returns true
 
       Puppet::SSL::Host.destroy("myhost").should be_true
     end
 
     it "should report that nothing was deleted if none of the classes returned true" do
       Puppet::SSL::Host.destroy("myhost").should == "Nothing was deleted"
     end
   end
 
   describe "when initializing" do
     it "should default its name to the :certname setting" do
       Puppet.settings.expects(:value).with(:certname).returns "myname"
 
       Puppet::SSL::Host.new.name.should == "myname"
     end
 
     it "should downcase a passed in name" do
       Puppet::SSL::Host.new("Host.Domain.Com").name.should == "host.domain.com"
     end
 
     it "should downcase the certname if it's used" do
       Puppet.settings.expects(:value).with(:certname).returns "Host.Domain.Com"
       Puppet::SSL::Host.new.name.should == "host.domain.com"
     end
 
     it "should indicate that it is a CA host if its name matches the ca_name constant" do
       Puppet::SSL::Host.stubs(:ca_name).returns "myca"
       Puppet::SSL::Host.new("myca").should be_ca
     end
   end
 
   describe "when managing its private key" do
     before do
       @realkey = "mykey"
       @key = Puppet::SSL::Key.new("mykey")
       @key.content = @realkey
     end
 
     it "should return nil if the key is not set and cannot be found" do
       Puppet::SSL::Key.indirection.expects(:find).with("myname").returns(nil)
       @host.key.should be_nil
     end
 
     it "should find the key in the Key class and return the Puppet instance" do
       Puppet::SSL::Key.indirection.expects(:find).with("myname").returns(@key)
       @host.key.should equal(@key)
     end
 
     it "should be able to generate and save a new key" do
       Puppet::SSL::Key.expects(:new).with("myname").returns(@key)
 
       @key.expects(:generate)
       Puppet::SSL::Key.indirection.expects(:save)
 
       @host.generate_key.should be_true
       @host.key.should equal(@key)
     end
 
     it "should not retain keys that could not be saved" do
       Puppet::SSL::Key.expects(:new).with("myname").returns(@key)
 
       @key.stubs(:generate)
       Puppet::SSL::Key.indirection.expects(:save).raises "eh"
 
       lambda { @host.generate_key }.should raise_error
       @host.key.should be_nil
     end
 
     it "should return any previously found key without requerying" do
       Puppet::SSL::Key.indirection.expects(:find).with("myname").returns(@key).once
       @host.key.should equal(@key)
       @host.key.should equal(@key)
     end
   end
 
   describe "when managing its certificate request" do
     before do
       @realrequest = "real request"
       @request = Puppet::SSL::CertificateRequest.new("myname")
       @request.content = @realrequest
     end
 
     it "should return nil if the key is not set and cannot be found" do
       Puppet::SSL::CertificateRequest.indirection.expects(:find).with("myname").returns(nil)
       @host.certificate_request.should be_nil
     end
 
     it "should find the request in the Key class and return it and return the Puppet SSL request" do
       Puppet::SSL::CertificateRequest.indirection.expects(:find).with("myname").returns @request
 
       @host.certificate_request.should equal(@request)
     end
 
     it "should generate a new key when generating the cert request if no key exists" do
       Puppet::SSL::CertificateRequest.expects(:new).with("myname").returns @request
 
       key = stub 'key', :public_key => mock("public_key"), :content => "mycontent"
 
       @host.expects(:key).times(2).returns(nil).then.returns(key)
       @host.expects(:generate_key).returns(key)
 
       @request.stubs(:generate)
       Puppet::SSL::CertificateRequest.indirection.stubs(:save)
 
       @host.generate_certificate_request
     end
 
     it "should be able to generate and save a new request using the private key" do
       Puppet::SSL::CertificateRequest.expects(:new).with("myname").returns @request
 
       key = stub 'key', :public_key => mock("public_key"), :content => "mycontent"
       @host.stubs(:key).returns(key)
       @request.expects(:generate).with("mycontent")
       Puppet::SSL::CertificateRequest.indirection.expects(:save).with(@request)
 
       @host.generate_certificate_request.should be_true
       @host.certificate_request.should equal(@request)
     end
 
     it "should return any previously found request without requerying" do
       Puppet::SSL::CertificateRequest.indirection.expects(:find).with("myname").returns(@request).once
 
       @host.certificate_request.should equal(@request)
       @host.certificate_request.should equal(@request)
     end
 
     it "should not keep its certificate request in memory if the request cannot be saved" do
       Puppet::SSL::CertificateRequest.expects(:new).with("myname").returns @request
 
       key = stub 'key', :public_key => mock("public_key"), :content => "mycontent"
       @host.stubs(:key).returns(key)
       @request.stubs(:generate)
       @request.stubs(:name).returns("myname")
       terminus = stub 'terminus'
       Puppet::SSL::CertificateRequest.indirection.expects(:prepare).returns(terminus)
       terminus.expects(:save).with { |req| req.instance == @request && req.key == "myname" }.raises "eh"
 
       lambda { @host.generate_certificate_request }.should raise_error
 
       @host.instance_eval { @certificate_request }.should be_nil
     end
   end
 
   describe "when managing its certificate" do
     before do
       @realcert = mock 'certificate'
       @cert = stub 'cert', :content => @realcert
 
       @host.stubs(:key).returns mock("key")
       @host.stubs(:certificate_matches_key?).returns true
     end
 
     it "should find the CA certificate if it does not have a certificate" do
       Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.stubs(:find).with("myname").returns @cert
 
       @host.certificate
     end
 
     it "should not find the CA certificate if it is the CA host" do
       @host.expects(:ca?).returns true
       Puppet::SSL::Certificate.indirection.stubs(:find)
       Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).never
 
       @host.certificate
     end
 
     it "should return nil if it cannot find a CA certificate" do
       Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns nil
       Puppet::SSL::Certificate.indirection.expects(:find).with("myname").never
 
       @host.certificate.should be_nil
     end
 
     it "should find the key if it does not have one" do
       Puppet::SSL::Certificate.indirection.stubs(:find)
       @host.expects(:key).returns mock("key")
 
       @host.certificate
     end
 
     it "should generate the key if one cannot be found" do
       Puppet::SSL::Certificate.indirection.stubs(:find)
 
       @host.expects(:key).returns nil
       @host.expects(:generate_key)
 
       @host.certificate
     end
 
     it "should find the certificate in the Certificate class and return the Puppet certificate instance" do
       Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.expects(:find).with("myname").returns @cert
 
       @host.certificate.should equal(@cert)
     end
 
     it "should fail if the found certificate does not match the private key" do
       @host.expects(:certificate_matches_key?).returns false
 
       Puppet::SSL::Certificate.indirection.stubs(:find).returns @cert
 
       lambda { @host.certificate }.should raise_error(Puppet::Error)
     end
 
     it "should return any previously found certificate" do
       Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.expects(:find).with("myname").returns(@cert).once
 
       @host.certificate.should equal(@cert)
       @host.certificate.should equal(@cert)
     end
   end
 
   it "should have a method for listing certificate hosts" do
     Puppet::SSL::Host.should respond_to(:search)
   end
 
   describe "when listing certificate hosts" do
     it "should default to listing all clients with any file types" do
       Puppet::SSL::Key.indirection.expects(:search).returns []
       Puppet::SSL::Certificate.indirection.expects(:search).returns []
       Puppet::SSL::CertificateRequest.indirection.expects(:search).returns []
       Puppet::SSL::Host.search
     end
 
     it "should be able to list only clients with a key" do
       Puppet::SSL::Key.indirection.expects(:search).returns []
       Puppet::SSL::Certificate.indirection.expects(:search).never
       Puppet::SSL::CertificateRequest.indirection.expects(:search).never
       Puppet::SSL::Host.search :for => Puppet::SSL::Key
     end
 
     it "should be able to list only clients with a certificate" do
       Puppet::SSL::Key.indirection.expects(:search).never
       Puppet::SSL::Certificate.indirection.expects(:search).returns []
       Puppet::SSL::CertificateRequest.indirection.expects(:search).never
       Puppet::SSL::Host.search :for => Puppet::SSL::Certificate
     end
 
     it "should be able to list only clients with a certificate request" do
       Puppet::SSL::Key.indirection.expects(:search).never
       Puppet::SSL::Certificate.indirection.expects(:search).never
       Puppet::SSL::CertificateRequest.indirection.expects(:search).returns []
       Puppet::SSL::Host.search :for => Puppet::SSL::CertificateRequest
     end
 
     it "should return a Host instance created with the name of each found instance", :'fails_on_ruby_1.9.2' => true do
       key = stub 'key', :name => "key"
       cert = stub 'cert', :name => "cert"
       csr = stub 'csr', :name => "csr"
 
       Puppet::SSL::Key.indirection.expects(:search).returns [key]
       Puppet::SSL::Certificate.indirection.expects(:search).returns [cert]
       Puppet::SSL::CertificateRequest.indirection.expects(:search).returns [csr]
 
       returned = []
       %w{key cert csr}.each do |name|
         result = mock(name)
         returned << result
         Puppet::SSL::Host.expects(:new).with(name).returns result
       end
 
       result = Puppet::SSL::Host.search
       returned.each do |r|
         result.should be_include(r)
       end
     end
   end
 
   it "should have a method for generating all necessary files" do
     Puppet::SSL::Host.new("me").should respond_to(:generate)
   end
 
   describe "when generating files" do
     before do
       @host = Puppet::SSL::Host.new("me")
       @host.stubs(:generate_key)
       @host.stubs(:generate_certificate_request)
     end
 
     it "should generate a key if one is not present" do
       @host.stubs(:key).returns nil
       @host.expects(:generate_key)
 
       @host.generate
     end
 
     it "should generate a certificate request if one is not present" do
       @host.expects(:certificate_request).returns nil
       @host.expects(:generate_certificate_request)
 
       @host.generate
     end
 
     describe "and it can create a certificate authority" do
       before do
         @ca = mock 'ca'
         Puppet::SSL::CertificateAuthority.stubs(:instance).returns @ca
       end
 
       it "should use the CA to sign its certificate request if it does not have a certificate" do
         @host.expects(:certificate).returns nil
 
         @ca.expects(:sign).with(@host.name)
 
         @host.generate
       end
     end
 
     describe "and it cannot create a certificate authority" do
       before do
         Puppet::SSL::CertificateAuthority.stubs(:instance).returns nil
       end
 
       it "should seek its certificate" do
         @host.expects(:certificate)
 
         @host.generate
       end
     end
   end
 
   it "should have a method for creating an SSL store" do
     Puppet::SSL::Host.new("me").should respond_to(:ssl_store)
   end
 
   it "should always return the same store" do
     host = Puppet::SSL::Host.new("foo")
     store = mock 'store'
     store.stub_everything
     OpenSSL::X509::Store.expects(:new).returns store
     host.ssl_store.should equal(host.ssl_store)
   end
 
   describe "when creating an SSL store" do
     before do
       @host = Puppet::SSL::Host.new("me")
       @store = mock 'store'
       @store.stub_everything
       OpenSSL::X509::Store.stubs(:new).returns @store
 
       Puppet.settings.stubs(:value).with(:localcacert).returns "ssl_host_testing"
 
       Puppet::SSL::CertificateRevocationList.indirection.stubs(:find).returns(nil)
     end
 
     it "should accept a purpose" do
       @store.expects(:purpose=).with "my special purpose"
       @host.ssl_store("my special purpose")
     end
 
     it "should default to OpenSSL::X509::PURPOSE_ANY as the purpose" do
       @store.expects(:purpose=).with OpenSSL::X509::PURPOSE_ANY
       @host.ssl_store
     end
 
     it "should add the local CA cert file" do
       Puppet.settings.stubs(:value).with(:localcacert).returns "/ca/cert/file"
       @store.expects(:add_file).with "/ca/cert/file"
       @host.ssl_store
     end
 
     describe "and a CRL is available" do
       before do
         @crl = stub 'crl', :content => "real_crl"
         Puppet::SSL::CertificateRevocationList.indirection.stubs(:find).returns @crl
         Puppet.settings.stubs(:value).with(:certificate_revocation).returns true
       end
 
       it "should add the CRL" do
         @store.expects(:add_crl).with "real_crl"
         @host.ssl_store
       end
 
       it "should set the flags to OpenSSL::X509::V_FLAG_CRL_CHECK_ALL|OpenSSL::X509::V_FLAG_CRL_CHECK" do
         @store.expects(:flags=).with OpenSSL::X509::V_FLAG_CRL_CHECK_ALL|OpenSSL::X509::V_FLAG_CRL_CHECK
         @host.ssl_store
       end
     end
   end
 
   describe "when waiting for a cert" do
     before do
       @host = Puppet::SSL::Host.new("me")
     end
 
     it "should generate its certificate request and attempt to read the certificate again if no certificate is found" do
       @host.expects(:certificate).times(2).returns(nil).then.returns "foo"
       @host.expects(:generate)
       @host.wait_for_cert(1)
     end
 
     it "should catch and log errors during CSR saving" do
       @host.expects(:certificate).times(2).returns(nil).then.returns "foo"
       @host.expects(:generate).raises(RuntimeError).then.returns nil
       @host.stubs(:sleep)
       @host.wait_for_cert(1)
     end
 
     it "should sleep and retry after failures saving the CSR if waitforcert is enabled" do
       @host.expects(:certificate).times(2).returns(nil).then.returns "foo"
       @host.expects(:generate).raises(RuntimeError).then.returns nil
       @host.expects(:sleep).with(1)
       @host.wait_for_cert(1)
     end
 
     it "should exit after failures saving the CSR of waitforcert is disabled" do
       @host.expects(:certificate).returns(nil)
       @host.expects(:generate).raises(RuntimeError)
       @host.expects(:puts)
       expect { @host.wait_for_cert(0) }.to exit_with 1
     end
 
     it "should exit if the wait time is 0 and it can neither find nor retrieve a certificate" do
       @host.stubs(:certificate).returns nil
       @host.expects(:generate)
       @host.expects(:puts)
       expect { @host.wait_for_cert(0) }.to exit_with 1
     end
 
     it "should sleep for the specified amount of time if no certificate is found after generating its certificate request" do
       @host.expects(:certificate).times(3).returns(nil).then.returns(nil).then.returns "foo"
       @host.expects(:generate)
 
       @host.expects(:sleep).with(1)
 
       @host.wait_for_cert(1)
     end
 
     it "should catch and log exceptions during certificate retrieval" do
       @host.expects(:certificate).times(3).returns(nil).then.raises(RuntimeError).then.returns("foo")
       @host.stubs(:generate)
       @host.stubs(:sleep)
 
       Puppet.expects(:err)
 
       @host.wait_for_cert(1)
     end
   end
 
   describe "when handling PSON" do
     include PuppetSpec::Files
 
     before do
       Puppet[:vardir] = tmpdir("ssl_test_vardir")
       Puppet[:ssldir] = tmpdir("ssl_test_ssldir")
       Puppet::SSLCertificates::CA.new.mkrootcert
       # localcacert is where each client stores the CA certificate
       # cacert is where the master stores the CA certificate
       # Since we need to play the role of both for testing we need them to be the same and exist
       Puppet[:cacert] = Puppet[:localcacert]
 
       @ca=Puppet::SSL::CertificateAuthority.new
     end
 
     describe "when converting to PSON" do
       it "should be able to identify a host with an unsigned certificate request" do
         host = Puppet::SSL::Host.new("bazinga")
         host.generate_certificate_request
         pson_hash = {
           "fingerprint"          => host.certificate_request.fingerprint,
           "desired_state"        => 'requested',
           "name"                 => host.name
         }
 
         result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
         result["fingerprint"].should == pson_hash["fingerprint"]
         result["name"].should        == pson_hash["name"]
         result["state"].should       == pson_hash["desired_state"]
       end
 
       it "should be able to identify a host with a signed certificate" do
         host = Puppet::SSL::Host.new("bazinga")
         host.generate_certificate_request
         @ca.sign(host.name)
         pson_hash = {
           "fingerprint"          => Puppet::SSL::Certificate.indirection.find(host.name).fingerprint,
           "desired_state"        => 'signed',
           "name"                 => host.name,
         }
 
         result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
         result["fingerprint"].should == pson_hash["fingerprint"]
         result["name"].should        == pson_hash["name"]
         result["state"].should       == pson_hash["desired_state"]
       end
 
       it "should be able to identify a host with a revoked certificate" do
         host = Puppet::SSL::Host.new("bazinga")
         host.generate_certificate_request
         @ca.sign(host.name)
         @ca.revoke(host.name)
         pson_hash = {
           "fingerprint"          => Puppet::SSL::Certificate.indirection.find(host.name).fingerprint,
           "desired_state"        => 'revoked',
           "name"                 => host.name,
         }
 
         result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
         result["fingerprint"].should == pson_hash["fingerprint"]
         result["name"].should        == pson_hash["name"]
         result["state"].should       == pson_hash["desired_state"]
       end
     end
 
     describe "when converting from PSON" do
       it "should return a Puppet::SSL::Host object with the specified desired state" do
         host = Puppet::SSL::Host.new("bazinga")
         host.desired_state="signed"
         pson_hash = {
           "name"  => host.name,
           "desired_state" => host.desired_state,
         }
         generated_host = Puppet::SSL::Host.from_pson(pson_hash)
         generated_host.desired_state.should == host.desired_state
         generated_host.name.should == host.name
       end
     end
   end
 end
diff --git a/spec/unit/ssl/inventory_spec.rb b/spec/unit/ssl/inventory_spec.rb
index d8606b1b4..3d141d0cd 100755
--- a/spec/unit/ssl/inventory_spec.rb
+++ b/spec/unit/ssl/inventory_spec.rb
@@ -1,179 +1,179 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/inventory'
 
 describe Puppet::SSL::Inventory do
   before do
     @class = Puppet::SSL::Inventory
   end
 
   it "should use the :certinventory setting for the path to the inventory file" do
     Puppet.settings.expects(:value).with(:cert_inventory).returns "/inven/tory"
 
     @class.any_instance.stubs(:rebuild)
 
     @class.new.path.should == "/inven/tory"
   end
 
   describe "when initializing" do
     it "should set its path to the inventory file" do
       Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
       @class.new.path.should == "/inven/tory"
     end
   end
 
   describe "when managing an inventory" do
     before do
       Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
 
       FileTest.stubs(:exist?).with("/inven/tory").returns true
 
       @inventory = @class.new
 
       @cert = mock 'cert'
     end
 
     describe "and creating the inventory file" do
       before do
         Puppet.settings.stubs(:write)
         FileTest.stubs(:exist?).with("/inven/tory").returns false
 
         Puppet::SSL::Certificate.indirection.stubs(:search).returns []
       end
 
       it "should log that it is building a new inventory file" do
         Puppet.expects(:notice)
 
         @inventory.rebuild
       end
 
       it "should use the Settings to write to the file" do
         Puppet.settings.expects(:write).with(:cert_inventory)
 
         @inventory.rebuild
       end
 
       it "should add a header to the file" do
         fh = mock 'filehandle'
         Puppet.settings.stubs(:write).yields fh
         fh.expects(:print).with { |str| str =~ /^#/ }
 
         @inventory.rebuild
       end
 
       it "should add formatted information on all existing certificates" do
         cert1 = mock 'cert1'
         cert2 = mock 'cert2'
 
         Puppet::SSL::Certificate.indirection.expects(:search).with("*").returns [cert1, cert2]
 
         @class.any_instance.expects(:add).with(cert1)
         @class.any_instance.expects(:add).with(cert2)
 
         @inventory.rebuild
       end
     end
 
     describe "and adding a certificate" do
       it "should build the inventory file if one does not exist" do
         Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
         Puppet.settings.stubs(:write)
 
         FileTest.expects(:exist?).with("/inven/tory").returns false
 
         @inventory.expects(:rebuild)
 
         @inventory.add(@cert)
       end
 
       it "should use the Settings to write to the file" do
         Puppet.settings.expects(:write).with(:cert_inventory, "a")
 
         @inventory.add(@cert)
       end
 
       it "should use the actual certificate if it was passed a Puppet certificate" do
         cert = Puppet::SSL::Certificate.new("mycert")
         cert.content = @cert
 
         fh = stub 'filehandle', :print => nil
         Puppet.settings.stubs(:write).yields fh
 
         @inventory.expects(:format).with(@cert)
 
         @inventory.add(@cert)
       end
 
       it "should add formatted certificate information to the end of the file" do
         fh = mock 'filehandle'
 
         Puppet.settings.stubs(:write).yields fh
 
         @inventory.expects(:format).with(@cert).returns "myformat"
 
         fh.expects(:print).with("myformat")
 
         @inventory.add(@cert)
       end
     end
 
-    describe "and formatting a certificate" do
+    describe "and formatting a certificate", :fails_on_windows => true do
       before do
         @cert = stub 'cert', :not_before => Time.now, :not_after => Time.now, :subject => "mycert", :serial => 15
       end
 
       it "should print the serial number as a 4 digit hex number in the first field" do
         @inventory.format(@cert).split[0].should == "0x000f" # 15 in hex
       end
 
       it "should print the not_before date in '%Y-%m-%dT%H:%M:%S%Z' format in the second field" do
         @cert.not_before.expects(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').returns "before_time"
 
         @inventory.format(@cert).split[1].should == "before_time"
       end
 
       it "should print the not_after date in '%Y-%m-%dT%H:%M:%S%Z' format in the third field" do
         @cert.not_after.expects(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').returns "after_time"
 
         @inventory.format(@cert).split[2].should == "after_time"
       end
 
       it "should print the subject in the fourth field" do
         @inventory.format(@cert).split[3].should == "mycert"
       end
 
       it "should add a carriage return" do
         @inventory.format(@cert).should =~ /\n$/
       end
 
       it "should produce a line consisting of the serial number, start date, expiration date, and subject" do
         # Just make sure our serial and subject bracket the lines.
         @inventory.format(@cert).should =~ /^0x.+mycert$/
       end
     end
 
     it "should be able to find a given host's serial number" do
       @inventory.should respond_to(:serial)
     end
 
     describe "and finding a serial number" do
       it "should return nil if the inventory file is missing" do
         FileTest.expects(:exist?).with("/inven/tory").returns false
         @inventory.serial(:whatever).should be_nil
       end
 
       it "should return the serial number from the line matching the provided name" do
         File.expects(:readlines).with("/inven/tory").returns ["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n"]
 
         @inventory.serial("me").should == 15
       end
 
       it "should return the number as an integer" do
         File.expects(:readlines).with("/inven/tory").returns ["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n"]
 
         @inventory.serial("me").should == 15
       end
     end
   end
 end
diff --git a/spec/unit/sslcertificates/ca_spec.rb b/spec/unit/sslcertificates/ca_spec.rb
index eea246ba1..2ff4036dd 100755
--- a/spec/unit/sslcertificates/ca_spec.rb
+++ b/spec/unit/sslcertificates/ca_spec.rb
@@ -1,110 +1,110 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet'
 require 'puppet/sslcertificates'
 require 'puppet/sslcertificates/ca'
 
-describe Puppet::SSLCertificates::CA do
+describe Puppet::SSLCertificates::CA, :fails_on_windows => true do
   before :all do
     @hosts = %w{host.domain.com Other.Testing.Com}
   end
 
   before :each do
     Puppet::Util::SUIDManager.stubs(:asuser).yields
     file = Tempfile.new("ca_testing")
     @dir = file.path
     file.delete
 
     Puppet.settings[:confdir] = @dir
     Puppet.settings[:vardir]  = @dir
 
     @ca = Puppet::SSLCertificates::CA.new
   end
 
   after :each do
     system("rm -rf #{@dir}")
   end
 
   describe 'when cleaning' do
     it 'should remove associated files' do
       dirs = [:csrdir, :signeddir, :publickeydir, :privatekeydir, :certdir]
 
       @hosts.each do |host|
         files = []
         dirs.each do |dir|
           dir = Puppet[dir]
 
           # Case insensitivity is handled through downcasing
           file = File.join(dir, host.downcase + '.pem')
 
           File.open(file, "w") do |f|
             f.puts "testing"
           end
 
           files << file
         end
 
         lambda { @ca.clean(host) }.should_not raise_error
 
         files.reject {|f| ! File.exists?(f)}.should be_empty
       end
     end
   end
 
   describe 'when mapping hosts to files' do
     it 'should correctly return the certfile' do
       @hosts.each do |host|
         value = nil
         lambda { value = @ca.host2certfile host }.should_not raise_error
 
         File.join(Puppet[:signeddir], host.downcase + '.pem').should == value
       end
     end
 
     it 'should correctly return the csrfile' do
       @hosts.each do |host|
         value = nil
         lambda { value = @ca.host2csrfile host }.should_not raise_error
 
         File.join(Puppet[:csrdir], host.downcase + '.pem').should == value
       end
     end
   end
 
   describe 'when listing' do
     it 'should find all csr' do
       list = []
 
       # Make some fake CSRs
       @hosts.each do |host|
         file = File.join(Puppet[:csrdir], host.downcase + '.pem')
         File.open(file, 'w') { |f| f.puts "yay" }
         list << host.downcase
       end
 
       @ca.list.sort.should == list.sort
     end
   end
 
   describe 'when creating a root certificate' do
     before :each do
       lambda { @ca.mkrootcert }.should_not raise_exception
     end
 
     it 'should store the public key' do
       File.exists?(Puppet[:capub]).should be_true
     end
 
     it 'should prepend "Puppet CA: " to the fqdn as the ca_name by default' do
       host_mock_fact = mock()
       host_mock_fact.expects(:value).returns('myhost')
       domain_mock_fact = mock()
       domain_mock_fact.expects(:value).returns('puppetlabs.lan')
       Facter.stubs(:[]).with('hostname').returns(host_mock_fact)
       Facter.stubs(:[]).with('domain').returns(domain_mock_fact)
 
       @ca.mkrootcert.name.should == 'Puppet CA: myhost.puppetlabs.lan'
     end
   end
 end
diff --git a/spec/unit/transaction/report_spec.rb b/spec/unit/transaction/report_spec.rb
index 08b892f21..033c4c740 100755
--- a/spec/unit/transaction/report_spec.rb
+++ b/spec/unit/transaction/report_spec.rb
@@ -1,312 +1,312 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/transaction/report'
 
 describe Puppet::Transaction::Report do
   include PuppetSpec::Files
   before do
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should set its host name to the node_name_value" do
     Puppet[:node_name_value] = 'mynode'
     Puppet::Transaction::Report.new("apply").host.should == "mynode"
   end
 
   it "should return its host name as its name" do
     r = Puppet::Transaction::Report.new("apply")
     r.name.should == r.host
   end
 
   it "should create an initialization timestamp" do
     Time.expects(:now).returns "mytime"
     Puppet::Transaction::Report.new("apply").time.should == "mytime"
   end
 
   it "should take a 'kind' as an argument" do
     Puppet::Transaction::Report.new("inspect").kind.should == "inspect"
   end
 
   it "should take a 'configuration_version' as an argument" do
     Puppet::Transaction::Report.new("inspect", "some configuration version").configuration_version.should == "some configuration version"
   end
 
   it "should be able to set configuration_version" do
     report = Puppet::Transaction::Report.new("inspect")
     report.configuration_version = "some version"
     report.configuration_version.should == "some version"
   end
 
   it "should not include whits" do
     Puppet::FileBucket::File.indirection.stubs(:save)
 
     filename = tmpfile('whit_test')
     file = Puppet::Type.type(:file).new(:path => filename)
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource(file)
 
     report = Puppet::Transaction::Report.new("apply")
 
     catalog.apply(:report => report)
     report.finalize_report
 
     report.resource_statuses.values.any? {|res| res.resource_type =~ /whit/i}.should be_false
     report.metrics['time'].values.any? {|metric| metric.first =~ /whit/i}.should be_false
   end
 
   describe "when accepting logs" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     it "should add new logs to the log list" do
       @report << "log"
       @report.logs[-1].should == "log"
     end
 
     it "should return self" do
       r = @report << "log"
       r.should equal(@report)
     end
   end
 
   describe "when accepting resource statuses" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     it "should add each status to its status list" do
       status = stub 'status', :resource => "foo"
       @report.add_resource_status status
       @report.resource_statuses["foo"].should equal(status)
     end
   end
 
   describe "when using the indirector" do
     it "should redirect :save to the indirection" do
       Facter.stubs(:value).returns("eh")
       @indirection = stub 'indirection', :name => :report
       Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
       report = Puppet::Transaction::Report.new("apply")
       @indirection.expects(:save)
       Puppet::Transaction::Report.indirection.save(report)
     end
 
     it "should default to the 'processor' terminus" do
       Puppet::Transaction::Report.indirection.terminus_class.should == :processor
     end
 
     it "should delegate its name attribute to its host method" do
       report = Puppet::Transaction::Report.new("apply")
       report.expects(:host).returns "me"
       report.name.should == "me"
     end
 
     after do
       Puppet::Util::Cacher.expire
     end
   end
 
   describe "when computing exit status" do
     it "should produce 2 if changes are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 0})
       report.exit_status.should == 2
     end
 
     it "should produce 4 if failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 1})
       report.exit_status.should == 4
     end
 
     it "should produce 6 if both changes and failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 1})
       report.exit_status.should == 6
     end
   end
 
   describe "before finalizing the report" do
     it "should have a status of 'failed'" do
       report = Puppet::Transaction::Report.new("apply")
       report.status.should == 'failed'
     end
   end
 
   describe "when finalizing the report" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     def metric(name, value)
       if metric = @report.metrics[name.to_s]
         metric[value]
       else
         nil
       end
     end
 
     def add_statuses(count, type = :file)
       count.times do |i|
         status = Puppet::Resource::Status.new(Puppet::Type.type(type).new(:title => make_absolute("/my/path#{i}")))
         yield status if block_given?
         @report.add_resource_status status
       end
     end
 
 
     [:time, :resources, :changes, :events].each do |type|
       it "should add #{type} metrics" do
         @report.finalize_report
         @report.metrics[type.to_s].should be_instance_of(Puppet::Transaction::Metric)
       end
     end
 
     describe "for resources" do
       it "should provide the total number of resources" do
         add_statuses(3)
 
         @report.finalize_report
         metric(:resources, "total").should == 3
       end
 
       Puppet::Resource::Status::STATES.each do |state|
         it "should provide the number of #{state} resources as determined by the status objects" do
           add_statuses(3) { |status| status.send(state.to_s + "=", true) }
 
           @report.finalize_report
           metric(:resources, state.to_s).should == 3
         end
       end
 
       it "should mark the report as 'failed' if there are failing resources" do
         add_statuses(1) { |status| status.failed = true }
         @report.finalize_report
         @report.status.should == 'failed'
       end
     end
 
     describe "for changes" do
       it "should provide the number of changes from the resource statuses and mark the report as 'changed'" do
         add_statuses(3) { |status| 3.times { status << Puppet::Transaction::Event.new(:status => 'success') } }
         @report.finalize_report
         metric(:changes, "total").should == 9
         @report.status.should == 'changed'
       end
 
       it "should provide a total even if there are no changes, and mark the report as 'unchanged'" do
         @report.finalize_report
         metric(:changes, "total").should == 0
         @report.status.should == 'unchanged'
       end
     end
 
     describe "for times" do
-      it "should provide the total amount of time for each resource type" do
+      it "should provide the total amount of time for each resource type", :fails_on_windows => true do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1
         end
         add_statuses(3, :exec) do |status|
           status.evaluation_time = 2
         end
         add_statuses(3, :mount) do |status|
           status.evaluation_time = 3
         end
 
         @report.finalize_report
 
         metric(:time, "file").should == 3
         metric(:time, "exec").should == 6
         metric(:time, "mount").should == 9
       end
 
       it "should add any provided times from external sources" do
         @report.add_times :foobar, 50
         @report.finalize_report
         metric(:time, "foobar").should == 50
       end
 
       it "should have a total time" do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1.25
         end
         @report.add_times :config_retrieval, 0.5
         @report.finalize_report
         metric(:time, "total").should == 4.25
       end
     end
 
     describe "for events" do
       it "should provide the total number of events" do
         add_statuses(3) do |status|
           3.times { |i| status.add_event(Puppet::Transaction::Event.new :status => 'success') }
         end
         @report.finalize_report
         metric(:events, "total").should == 9
       end
 
       it "should provide the total even if there are no events" do
         @report.finalize_report
         metric(:events, "total").should == 0
       end
 
       Puppet::Transaction::Event::EVENT_STATUSES.each do |status_name|
         it "should provide the number of #{status_name} events" do
           add_statuses(3) do |status|
             3.times do |i|
               event = Puppet::Transaction::Event.new
               event.status = status_name
               status.add_event(event)
             end
           end
 
           @report.finalize_report
           metric(:events, status_name).should == 9
         end
       end
     end
   end
 
   describe "when producing a summary" do
     before do
       resource = Puppet::Type.type(:notify).new(:name => "testing")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
       trans = catalog.apply
 
       @report = trans.report
       @report.finalize_report
     end
 
     %w{changes time resources events}.each do |main|
       it "should include the key #{main} in the raw summary hash" do
         @report.raw_summary.should be_key main
       end
     end
 
     it "should include the last run time in the raw summary hash" do
       Time.stubs(:now).returns(Time.utc(2010,11,10,12,0,24))
       @report.raw_summary["time"]["last_run"].should == 1289390424
     end
 
     %w{Changes Total Resources Time Events}.each do |main|
       it "should include information on #{main} in the textual summary" do
         @report.summary.should be_include(main)
       end
     end
   end
 
   describe "when outputting yaml" do
     it "should not include @external_times" do
       report = Puppet::Transaction::Report.new('apply')
       report.add_times('config_retrieval', 1.0)
       report.to_yaml_properties.should_not include('@external_times')
     end
   end
 end
diff --git a/spec/unit/type/exec_spec.rb b/spec/unit/type/exec_spec.rb
index 175e307f9..2861bb0e3 100755
--- a/spec/unit/type/exec_spec.rb
+++ b/spec/unit/type/exec_spec.rb
@@ -1,666 +1,666 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec) do
   include PuppetSpec::Files
 
   def exec_tester(command, exitstatus = 0, rest = {})
     @user_name  = 'some_user_name'
     @group_name = 'some_group_name'
     Puppet.features.stubs(:root?).returns(true)
 
     output = rest.delete(:output) || ''
     tries  = rest[:tries] || 1
 
     args = {
       :name      => command,
       :path      => @example_path,
       :user      => @user_name,
       :group     => @group_name,
       :logoutput => false,
       :loglevel  => :err,
       :returns   => 0
     }.merge(rest)
 
     exec = Puppet::Type.type(:exec).new(args)
 
     status = stub "process", :exitstatus => exitstatus
     Puppet::Util::SUIDManager.expects(:run_and_capture).times(tries).
       with([command], @user_name, @group_name).returns([output, status])
 
     return exec
   end
 
   before do
     @command = make_absolute('/bin/true whatever')
     @executable = make_absolute('/bin/true')
     @bogus_cmd = make_absolute('/bogus/cmd')
   end
 
   describe "when not stubbing the provider", :fails_on_windows => true do
     before do
       File.stubs(:exists?).returns false
       File.stubs(:exists?).with(@executable).returns true
       File.stubs(:exists?).with('/bin/false').returns true
       @example_path = Puppet.features.posix? ? %w{/usr/bin /bin} : [ "C:/Program Files/something/bin", "C:/Ruby/bin" ]
       File.stubs(:exists?).with(File.join(@example_path[0],"true")).returns true
       File.stubs(:exists?).with(File.join(@example_path[0],"false")).returns true
     end
 
     it "should return :executed_command as its event" do
       resource = Puppet::Type.type(:exec).new :command => @command
       resource.parameter(:returns).event.name.should == :executed_command
     end
 
     describe "when execing" do
       it "should use the 'run_and_capture' method to exec" do
         exec_tester("true").refresh.should == :executed_command
       end
 
       it "should report a failure" do
         proc { exec_tester('false', 1).refresh }.
           should raise_error(Puppet::Error, /^false returned 1 instead of/)
       end
 
       it "should not report a failure if the exit status is specified in a returns array" do
         proc { exec_tester("false", 1, :returns => [0, 1]).refresh }.should_not raise_error
       end
 
       it "should report a failure if the exit status is not specified in a returns array" do
         proc { exec_tester('false', 1, :returns => [0, 100]).refresh }.
           should raise_error(Puppet::Error, /^false returned 1 instead of/)
       end
 
       it "should log the output on success" do
         output = "output1\noutput2\n"
         exec_tester('false', 0, :output => output, :logoutput => true).refresh
         output.split("\n").each do |line|
           log = @logs.shift
           log.level.should == :err
           log.message.should == line
         end
       end
 
       it "should log the output on failure" do
         output = "output1\noutput2\n"
         proc { exec_tester('false', 1, :output => output, :logoutput => true).refresh }.
           should raise_error(Puppet::Error)
 
         output.split("\n").each do |line|
           log = @logs.shift
           log.level.should == :err
           log.message.should == line
         end
       end
     end
 
     describe "when logoutput=>on_failure is set" do
       it "should log the output on failure" do
         output = "output1\noutput2\n"
         proc { exec_tester('false', 1, :output => output, :logoutput => :on_failure).refresh }.
           should raise_error(Puppet::Error, /^false returned 1 instead of/)
 
         output.split("\n").each do |line|
           log = @logs.shift
           log.level.should == :err
           log.message.should == line
         end
       end
 
       it "should log the output on failure when returns is specified as an array" do
         output = "output1\noutput2\n"
 
         proc {
           exec_tester('false', 1, :output => output, :returns => [0, 100],
                :logoutput => :on_failure).refresh
         }.should raise_error(Puppet::Error, /^false returned 1 instead of/)
 
         output.split("\n").each do |line|
           log = @logs.shift
           log.level.should == :err
           log.message.should == line
         end
       end
 
       it "shouldn't log the output on success" do
         exec_tester('true', 0, :output => "a\nb\nc\n", :logoutput => :on_failure).refresh
         @logs.should == []
       end
     end
 
     it "shouldn't log the output on success when non-zero exit status is in a returns array" do
       exec_tester("true", 100, :output => "a\n", :logoutput => :on_failure, :returns => [1, 100]).refresh
       @logs.should == []
     end
 
     describe " when multiple tries are set," do
       it "should repeat the command attempt 'tries' times on failure and produce an error" do
         tries = 5
         resource = exec_tester("false", 1, :tries => tries, :try_sleep => 0)
         proc { resource.refresh }.should raise_error(Puppet::Error)
       end
     end
   end
 
   it "should be able to autorequire files mentioned in the command", :fails_on_windows => true do
     foo = make_absolute('/bin/foo')
     catalog = Puppet::Resource::Catalog.new
     tmp = Puppet::Type.type(:file).new(:name => foo)
     catalog.add_resource tmp
     execer = Puppet::Type.type(:exec).new(:name => foo)
     catalog.add_resource execer
 
     catalog.relationship_graph.dependencies(execer).should == [tmp]
   end
 
   describe "when handling the path parameter", :fails_on_windows => true do
     expect = %w{one two three four}
     { "an array"                        => expect,
       "a colon separated list"          => "one:two:three:four",
       "a semi-colon separated list"     => "one;two;three;four",
       "both array and colon lists"      => ["one", "two:three", "four"],
       "both array and semi-colon lists" => ["one", "two;three", "four"],
       "colon and semi-colon lists"      => ["one:two", "three;four"]
     }.each do |test, input|
       it "should accept #{test}" do
         type = Puppet::Type.type(:exec).new(:name => @command, :path => input)
         type[:path].should == expect
       end
     end
   end
 
-  describe "when setting user" do
+  describe "when setting user", :fails_on_windows => true do
     it "should fail if we are not root" do
       Puppet.features.stubs(:root?).returns(false)
       expect { Puppet::Type.type(:exec).new(:name => @command, :user => 'input') }.
         should raise_error Puppet::Error, /Parameter user failed/
     end
 
     ['one', 2, 'root', 4294967295, 4294967296].each do |value|
       it "should accept '#{value}' as user if we are root" do
         Puppet.features.stubs(:root?).returns(true)
         type = Puppet::Type.type(:exec).new(:name => @command, :user => value)
         type[:user].should == value
       end
     end
   end
 
   describe "when setting group" do
     shared_examples_for "exec[:group]" do
       ['one', 2, 'wheel', 4294967295, 4294967296].each do |value|
-        it "should accept '#{value}' without error or judgement" do
+        it "should accept '#{value}' without error or judgement", :fails_on_windows => true do
           type = Puppet::Type.type(:exec).new(:name => @command, :group => value)
           type[:group].should == value
         end
       end
     end
 
     describe "when running as root" do
       before :each do Puppet.features.stubs(:root?).returns(true) end
       it_behaves_like "exec[:group]"
     end
 
     describe "when not running as root" do
       before :each do Puppet.features.stubs(:root?).returns(false) end
       it_behaves_like "exec[:group]"
     end
   end
 
   describe "when setting cwd" do
     it_should_behave_like "all path parameters", :cwd, :array => false do
       def instance(path)
         Puppet::Type.type(:exec).new(:name => @executable, :cwd => path)
       end
     end
   end
 
   shared_examples_for "all exec command parameters" do |param|
     { "relative" => "example", "absolute" => "/bin/example" }.sort.each do |name, command|
       describe "if command is #{name}" do
         before :each do
           @param = param
         end
 
         def test(command, valid)
           if @param == :name then
             instance = Puppet::Type.type(:exec).new()
           else
             instance = Puppet::Type.type(:exec).new(:name => @executable)
           end
           if valid then
             instance.provider.expects(:validatecmd).returns(true)
           else
             instance.provider.expects(:validatecmd).raises(Puppet::Error, "from a stub")
           end
           instance[@param] = command
         end
 
         it "should work if the provider calls the command valid" do
           expect { test(command, true) }.should_not raise_error
         end
 
         it "should fail if the provider calls the command invalid" do
           expect { test(command, false) }.
             should raise_error Puppet::Error, /Parameter #{@param} failed: from a stub/
         end
       end
     end
   end
 
   shared_examples_for "all exec command parameters that take arrays" do |param|
     describe "when given an array of inputs" do
       before :each do
         @test = Puppet::Type.type(:exec).new(:name => @executable)
       end
 
       it "should accept the array when all commands return valid" do
         input = %w{one two three}
         @test.provider.expects(:validatecmd).times(input.length).returns(true)
         @test[param] = input
         @test[param].should == input
       end
 
       it "should reject the array when any commands return invalid" do
         input = %w{one two three}
         @test.provider.expects(:validatecmd).with(input.first).returns(false)
         input[1..-1].each do |cmd|
           @test.provider.expects(:validatecmd).with(cmd).returns(true)
         end
         @test[param] = input
         @test[param].should == input
       end
 
       it "should reject the array when all commands return invalid" do
         input = %w{one two three}
         @test.provider.expects(:validatecmd).times(input.length).returns(false)
         @test[param] = input
         @test[param].should == input
       end
     end
   end
 
   describe "when setting refresh" do
     it_should_behave_like "all exec command parameters", :refresh
   end
 
   describe "for simple parameters" do
     before :each do
       @exec = Puppet::Type.type(:exec).new(:name => @executable)
     end
 
     describe "when setting environment" do
       { "single values"   => "foo=bar",
         "multiple values" => ["foo=bar", "baz=quux"],
       }.each do |name, data|
         it "should accept #{name}" do
           @exec[:environment] = data
           @exec[:environment].should == data
         end
       end
 
       { "single values" => "foo",
         "only values"   => ["foo", "bar"],
         "any values"    => ["foo=bar", "baz"]
       }.each do |name, data|
         it "should reject #{name} without assignment" do
           expect { @exec[:environment] = data }.
             should raise_error Puppet::Error, /Invalid environment setting/
         end
       end
     end
 
     describe "when setting timeout" do
       [0, 0.1, 1, 10, 4294967295].each do |valid|
         it "should accept '#{valid}' as valid" do
           @exec[:timeout] = valid
           @exec[:timeout].should == valid
         end
 
         it "should accept '#{valid}' in an array as valid" do
           @exec[:timeout] = [valid]
           @exec[:timeout].should == valid
         end
       end
 
       ['1/2', '', 'foo', '5foo'].each do |invalid|
         it "should reject '#{invalid}' as invalid" do
           expect { @exec[:timeout] = invalid }.
             should raise_error Puppet::Error, /The timeout must be a number/
         end
 
         it "should reject '#{invalid}' in an array as invalid" do
           expect { @exec[:timeout] = [invalid] }.
             should raise_error Puppet::Error, /The timeout must be a number/
         end
       end
 
       it "should fail if timeout is exceeded" do
         File.stubs(:exists?).with('/bin/sleep').returns(true)
         File.stubs(:exists?).with('sleep').returns(false)
         sleep_exec = Puppet::Type.type(:exec).new(:name => 'sleep 1', :path => ['/bin'], :timeout => '0.2')
         lambda { sleep_exec.refresh }.should raise_error Puppet::Error, "Command exceeded timeout"
       end
 
       it "should convert timeout to a float" do
         command = make_absolute('/bin/false')
         resource = Puppet::Type.type(:exec).new :command => command, :timeout => "12"
         resource[:timeout].should be_a(Float)
         resource[:timeout].should == 12.0
       end
 
       it "should munge negative timeouts to 0.0" do
         command = make_absolute('/bin/false')
         resource = Puppet::Type.type(:exec).new :command => command, :timeout => "-12.0"
         resource.parameter(:timeout).value.should be_a(Float)
         resource.parameter(:timeout).value.should == 0.0
       end
     end
 
     describe "when setting tries" do
       [1, 10, 4294967295].each do |valid|
         it "should accept '#{valid}' as valid" do
           @exec[:tries] = valid
           @exec[:tries].should == valid
         end
 
         if "REVISIT: too much test log spam" == "a good thing" then
           it "should accept '#{valid}' in an array as valid" do
             pending "inconsistent, but this is not supporting arrays, unlike timeout"
             @exec[:tries] = [valid]
             @exec[:tries].should == valid
           end
         end
       end
 
       [-3.5, -1, 0, 0.2, '1/2', '1_000_000', '+12', '', 'foo'].each do |invalid|
         it "should reject '#{invalid}' as invalid" do
           expect { @exec[:tries] = invalid }.
             should raise_error Puppet::Error, /Tries must be an integer/
         end
 
         if "REVISIT: too much test log spam" == "a good thing" then
           it "should reject '#{invalid}' in an array as invalid" do
             pending "inconsistent, but this is not supporting arrays, unlike timeout"
             expect { @exec[:tries] = [invalid] }.
               should raise_error Puppet::Error, /Tries must be an integer/
           end
         end
       end
     end
 
     describe "when setting try_sleep" do
       [0, 0.2, 1, 10, 4294967295].each do |valid|
         it "should accept '#{valid}' as valid" do
           @exec[:try_sleep] = valid
           @exec[:try_sleep].should == valid
         end
 
         if "REVISIT: too much test log spam" == "a good thing" then
           it "should accept '#{valid}' in an array as valid" do
             pending "inconsistent, but this is not supporting arrays, unlike timeout"
             @exec[:try_sleep] = [valid]
             @exec[:try_sleep].should == valid
           end
         end
       end
 
       { -3.5        => "cannot be a negative number",
         -1          => "cannot be a negative number",
         '1/2'       => 'must be a number',
         '1_000_000' => 'must be a number',
         '+12'       => 'must be a number',
         ''          => 'must be a number',
         'foo'       => 'must be a number',
       }.each do |invalid, error|
         it "should reject '#{invalid}' as invalid" do
           expect { @exec[:try_sleep] = invalid }.
             should raise_error Puppet::Error, /try_sleep #{error}/
         end
 
         if "REVISIT: too much test log spam" == "a good thing" then
           it "should reject '#{invalid}' in an array as invalid" do
             pending "inconsistent, but this is not supporting arrays, unlike timeout"
             expect { @exec[:try_sleep] = [invalid] }.
               should raise_error Puppet::Error, /try_sleep #{error}/
           end
         end
       end
     end
 
     describe "when setting refreshonly" do
       [:true, :false].each do |value|
         it "should accept '#{value}'" do
           @exec[:refreshonly] = value
           @exec[:refreshonly].should == value
         end
       end
 
       [1, 0, "1", "0", "yes", "y", "no", "n"].each do |value|
         it "should reject '#{value}'" do
           expect { @exec[:refreshonly] = value }.
             should raise_error(Puppet::Error,
               /Invalid value #{value.inspect}\. Valid values are true, false/
             )
         end
       end
     end
 
     describe "when setting creates" do
       it_should_behave_like "all path parameters", :creates, :array => true do
         def instance(path)
           Puppet::Type.type(:exec).new(:name => @executable, :creates => path)
         end
       end
     end
   end
 
   describe "when setting unless" do
     it_should_behave_like "all exec command parameters", :unless
     it_should_behave_like "all exec command parameters that take arrays", :unless
   end
 
   describe "when setting onlyif" do
     it_should_behave_like "all exec command parameters", :onlyif
     it_should_behave_like "all exec command parameters that take arrays", :onlyif
   end
 
   describe "#check" do
     before :each do
       @test = Puppet::Type.type(:exec).new(:name => @executable)
     end
 
     describe ":refreshonly" do
       { :true => false, :false => true }.each do |input, result|
         it "should return '#{result}' when given '#{input}'" do
           @test[:refreshonly] = input
           @test.check_all_attributes.should == result
         end
       end
     end
 
     describe ":creates" do
       before :all do
         @exist   = "/"
         @unexist = "/this/path/should/never/exist"
         while FileTest.exist?(@unexist) do @unexist += "/foo" end
       end
 
       context "with a single item" do
         it "should run when the item does not exist" do
           @test[:creates] = @unexist
           @test.check_all_attributes.should == true
         end
 
         it "should not run when the item exists" do
           @test[:creates] = @exist
           @test.check_all_attributes.should == false
         end
       end
 
       context "with an array with one item" do
         it "should run when the item does not exist" do
           @test[:creates] = [@unexist]
           @test.check_all_attributes.should == true
         end
 
         it "should not run when the item exists" do
           @test[:creates] = [@exist]
           @test.check_all_attributes.should == false
         end
       end
 
       context "with an array with multiple items" do
         it "should run when all items do not exist" do
           @test[:creates] = [@unexist] * 3
           @test.check_all_attributes.should == true
         end
 
         it "should not run when one item exists" do
           @test[:creates] = [@unexist, @exist, @unexist]
           @test.check_all_attributes.should == false
         end
 
         it "should not run when all items exist" do
           @test[:creates] = [@exist] * 3
         end
       end
     end
 
     { :onlyif => { :pass => false, :fail => true  },
       :unless => { :pass => true,  :fail => false },
     }.each do |param, sense|
       describe ":#{param}" do
         before :each do
           @pass = make_absolute("/magic/pass")
           @fail = make_absolute("/magic/fail")
 
           @pass_status = stub('status', :exitstatus => sense[:pass] ? 0 : 1)
           @fail_status = stub('status', :exitstatus => sense[:fail] ? 0 : 1)
 
           @test.provider.stubs(:checkexe).returns(true)
           [true, false].each do |check|
             @test.provider.stubs(:run).with(@pass, check).
               returns(['test output', @pass_status])
             @test.provider.stubs(:run).with(@fail, check).
               returns(['test output', @fail_status])
           end
         end
 
         context "with a single item" do
           it "should run if the command exits non-zero" do
             @test[param] = @fail
             @test.check_all_attributes.should == true
           end
 
           it "should not run if the command exits zero" do
             @test[param] = @pass
             @test.check_all_attributes.should == false
           end
         end
 
         context "with an array with a single item" do
           it "should run if the command exits non-zero" do
             @test[param] = [@fail]
             @test.check_all_attributes.should == true
           end
 
           it "should not run if the command exits zero" do
             @test[param] = [@pass]
             @test.check_all_attributes.should == false
           end
         end
 
         context "with an array with multiple items" do
           it "should run if all the commands exits non-zero" do
             @test[param] = [@fail] * 3
             @test.check_all_attributes.should == true
           end
 
           it "should not run if one command exits zero" do
             @test[param] = [@pass, @fail, @pass]
             @test.check_all_attributes.should == false
           end
 
           it "should not run if all command exits zero" do
             @test[param] = [@pass] * 3
             @test.check_all_attributes.should == false
           end
         end
       end
     end
   end
 
   describe "#retrieve", :fails_on_windows => true do
     before :each do
       @exec_resource = Puppet::Type.type(:exec).new(:name => @bogus_cmd)
     end
 
     it "should return :notrun when check_all_attributes returns true" do
       @exec_resource.stubs(:check_all_attributes).returns true
       @exec_resource.retrieve[:returns].should == :notrun
     end
 
     it "should return default exit code 0 when check_all_attributes returns false" do
       @exec_resource.stubs(:check_all_attributes).returns false
       @exec_resource.retrieve[:returns].should == ['0']
     end
 
     it "should return the specified exit code when check_all_attributes returns false" do
       @exec_resource.stubs(:check_all_attributes).returns false
       @exec_resource[:returns] = 42
       @exec_resource.retrieve[:returns].should == ["42"]
     end
   end
 
   describe "#output" do
     before :each do
       @exec_resource = Puppet::Type.type(:exec).new(:name => @bogus_cmd)
     end
 
     it "should return the provider's run output" do
       provider = stub 'provider'
       status = stubs "process_status"
       status.stubs(:exitstatus).returns("0")
       provider.expects(:run).returns(["silly output", status])
       @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
       @exec_resource.output.should == 'silly output'
     end
   end
 
   describe "#refresh" do
     before :each do
       @exec_resource = Puppet::Type.type(:exec).new(:name => @bogus_cmd)
     end
 
     it "should call provider run with the refresh parameter if it is set" do
       myother_bogus_cmd = make_absolute('/myother/bogus/cmd')
       provider = stub 'provider'
       @exec_resource.stubs(:provider).returns(provider)
       @exec_resource.stubs(:[]).with(:refresh).returns(myother_bogus_cmd)
       provider.expects(:run).with(myother_bogus_cmd)
 
       @exec_resource.refresh
     end
 
     it "should call provider run with the specified command if the refresh parameter is not set" do
       provider = stub 'provider'
       status = stubs "process_status"
       status.stubs(:exitstatus).returns("0")
       provider.expects(:run).with(@bogus_cmd).returns(["silly output", status])
       @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
     end
 
     it "should not run the provider if check_all_attributes is false" do
       @exec_resource.stubs(:check_all_attributes).returns false
       provider = stub 'provider'
       provider.expects(:run).never
       @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
     end
   end
 end
diff --git a/spec/unit/type/file/content_spec.rb b/spec/unit/type/file/content_spec.rb
index 7af5f9d83..6a2f3f4b3 100755
--- a/spec/unit/type/file/content_spec.rb
+++ b/spec/unit/type/file/content_spec.rb
@@ -1,435 +1,435 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 content = Puppet::Type.type(:file).attrclass(:content)
 describe content do
   include PuppetSpec::Files
   before do
     @filename = tmpfile('testfile')
     @resource = Puppet::Type.type(:file).new :path => @filename
     File.open(@filename, 'w') {|f| f.write "initial file content"}
     content.stubs(:standalone?).returns(false)
   end
 
   describe "when determining the checksum type" do
     it "should use the type specified in the source checksum if a source is set" do
       @resource[:source] = "/foo"
       @resource.parameter(:source).expects(:checksum).returns "{md5lite}eh"
 
       @content = content.new(:resource => @resource)
       @content.checksum_type.should == :md5lite
     end
 
     it "should use the type specified by the checksum parameter if no source is set" do
       @resource[:checksum] = :md5lite
 
       @content = content.new(:resource => @resource)
       @content.checksum_type.should == :md5lite
     end
   end
 
   describe "when determining the actual content to write" do
     it "should use the set content if available" do
       @content = content.new(:resource => @resource)
       @content.should = "ehness"
       @content.actual_content.should == "ehness"
     end
 
     it "should not use the content from the source if the source is set" do
       source = mock 'source'
 
       @resource.expects(:parameter).never.with(:source).returns source
 
       @content = content.new(:resource => @resource)
       @content.actual_content.should be_nil
     end
   end
 
   describe "when setting the desired content" do
     it "should make the actual content available via an attribute" do
       @content = content.new(:resource => @resource)
       @content.stubs(:checksum_type).returns "md5"
       @content.should = "this is some content"
 
       @content.actual_content.should == "this is some content"
     end
 
     it "should store the checksum as the desired content" do
       @content = content.new(:resource => @resource)
       digest = Digest::MD5.hexdigest("this is some content")
 
       @content.stubs(:checksum_type).returns "md5"
       @content.should = "this is some content"
 
       @content.should.must == "{md5}#{digest}"
     end
 
     it "should not checksum 'absent'" do
       @content = content.new(:resource => @resource)
       @content.should = :absent
 
       @content.should.must == :absent
     end
 
     it "should accept a checksum as the desired content" do
       @content = content.new(:resource => @resource)
       digest = Digest::MD5.hexdigest("this is some content")
 
       string = "{md5}#{digest}"
       @content.should = string
 
       @content.should.must == string
     end
   end
 
   describe "when retrieving the current content" do
     it "should return :absent if the file does not exist" do
       @content = content.new(:resource => @resource)
       @resource.expects(:stat).returns nil
 
       @content.retrieve.should == :absent
     end
 
     it "should not manage content on directories" do
       @content = content.new(:resource => @resource)
 
       stat = mock 'stat', :ftype => "directory"
       @resource.expects(:stat).returns stat
 
       @content.retrieve.should be_nil
     end
 
     it "should not manage content on links" do
       @content = content.new(:resource => @resource)
 
       stat = mock 'stat', :ftype => "link"
       @resource.expects(:stat).returns stat
 
       @content.retrieve.should be_nil
     end
 
     it "should always return the checksum as a string" do
       @content = content.new(:resource => @resource)
       @resource[:checksum] = :mtime
 
       stat = mock 'stat', :ftype => "file"
       @resource.expects(:stat).returns stat
 
       time = Time.now
       @resource.parameter(:checksum).expects(:mtime_file).with(@resource[:path]).returns time
 
       @content.retrieve.should == "{mtime}#{time}"
     end
 
     it "should return the checksum of the file if it exists and is a normal file" do
       @content = content.new(:resource => @resource)
       stat = mock 'stat', :ftype => "file"
       @resource.expects(:stat).returns stat
       @resource.parameter(:checksum).expects(:md5_file).with(@resource[:path]).returns "mysum"
 
       @content.retrieve.should == "{md5}mysum"
     end
   end
 
   describe "when testing whether the content is in sync" do
     before do
       @resource[:ensure] = :file
       @content = content.new(:resource => @resource)
     end
 
     it "should return true if the resource shouldn't be a regular file" do
       @resource.expects(:should_be_file?).returns false
       @content.should = "foo"
       @content.must be_safe_insync("whatever")
     end
 
     it "should return false if the current content is :absent" do
       @content.should = "foo"
       @content.should_not be_safe_insync(:absent)
     end
 
     it "should return false if the file should be a file but is not present" do
       @resource.expects(:should_be_file?).returns true
       @content.should = "foo"
 
       @content.should_not be_safe_insync(:absent)
     end
 
     describe "and the file exists" do
       before do
         @resource.stubs(:stat).returns mock("stat")
       end
 
       it "should return false if the current contents are different from the desired content" do
         @content.should = "some content"
         @content.should_not be_safe_insync("other content")
       end
 
       it "should return true if the sum for the current contents is the same as the sum for the desired content" do
         @content.should = "some content"
         @content.must be_safe_insync("{md5}" + Digest::MD5.hexdigest("some content"))
       end
 
       describe "and Puppet[:show_diff] is set" do
         before do
           Puppet[:show_diff] = true
         end
 
         it "should display a diff if the current contents are different from the desired content" do
           @content.should = "some content"
           @content.expects(:diff).returns("my diff").once
           @content.expects(:print).with("my diff").once
 
           @content.safe_insync?("other content")
         end
 
         it "should not display a diff if the sum for the current contents is the same as the sum for the desired content" do
           @content.should = "some content"
           @content.expects(:diff).never
 
           @content.safe_insync?("{md5}" + Digest::MD5.hexdigest("some content"))
         end
       end
     end
 
     describe "and :replace is false" do
       before do
         @resource.stubs(:replace?).returns false
       end
 
       it "should be insync if the file exists and the content is different" do
         @resource.stubs(:stat).returns mock('stat')
 
         @content.must be_safe_insync("whatever")
       end
 
       it "should be insync if the file exists and the content is right" do
         @resource.stubs(:stat).returns mock('stat')
 
         @content.must be_safe_insync("something")
       end
 
       it "should not be insync if the file does not exist" do
         @content.should = "foo"
         @content.should_not be_safe_insync(:absent)
       end
     end
   end
 
   describe "when changing the content" do
     before do
       @content = content.new(:resource => @resource)
       @content.should = "some content"
 
       @resource.stubs(:[]).with(:path).returns "/boo"
       @resource.stubs(:stat).returns "eh"
     end
 
     it "should use the file's :write method to write the content" do
       @resource.expects(:write).with(:content)
 
       @content.sync
     end
 
     it "should return :file_changed if the file already existed" do
       @resource.expects(:stat).returns "something"
       @resource.stubs(:write)
       @content.sync.should == :file_changed
     end
 
     it "should return :file_created if the file did not exist" do
       @resource.expects(:stat).returns nil
       @resource.stubs(:write)
       @content.sync.should == :file_created
     end
   end
 
   describe "when writing" do
     before do
       @content = content.new(:resource => @resource)
     end
 
     it "should attempt to read from the filebucket if no actual content nor source exists" do
       @fh = File.open(@filename, 'w')
       @content.should = "{md5}foo"
       @content.resource.bucket.class.any_instance.stubs(:getfile).returns "foo"
       @content.write(@fh)
     end
 
     describe "from actual content" do
       before(:each) do
         @content.stubs(:actual_content).returns("this is content")
       end
 
       it "should write to the given file handle" do
         @fh.expects(:print).with("this is content")
         @content.write(@fh)
       end
 
       it "should return the current checksum value" do
         @resource.parameter(:checksum).expects(:sum_stream).returns "checksum"
         @content.write(@fh).should == "checksum"
       end
     end
 
     describe "from a file bucket" do
       it "should fail if a file bucket cannot be retrieved" do
         @content.should = "{md5}foo"
         @content.resource.expects(:bucket).returns nil
         lambda { @content.write(@fh) }.should raise_error(Puppet::Error)
       end
 
       it "should fail if the file bucket cannot find any content" do
         @content.should = "{md5}foo"
         bucket = stub 'bucket'
         @content.resource.expects(:bucket).returns bucket
         bucket.expects(:getfile).with("foo").raises "foobar"
         lambda { @content.write(@fh) }.should raise_error(Puppet::Error)
       end
 
       it "should write the returned content to the file" do
         @content.should = "{md5}foo"
         bucket = stub 'bucket'
         @content.resource.expects(:bucket).returns bucket
         bucket.expects(:getfile).with("foo").returns "mycontent"
 
         @fh.expects(:print).with("mycontent")
         @content.write(@fh)
       end
     end
 
-    describe "from local source" do
+    describe "from local source", :fails_on_windows => true do
       before(:each) do
         @resource = Puppet::Type.type(:file).new :path => @filename, :backup => false
         @sourcename = tmpfile('source')
         @source_content = "source file content"*10000
         @sourcefile = File.open(@sourcename, 'w') {|f| f.write @source_content}
 
         @content = @resource.newattr(:content)
         @source = @resource.newattr(:source)
         @source.stubs(:metadata).returns stub_everything('metadata', :source => @sourcename, :ftype => 'file')
       end
 
       it "should copy content from the source to the file" do
         @resource.write(@source)
         File.read(@filename).should == @source_content
       end
 
       it "should return the checksum computed" do
         File.open(@filename, 'w') do |file|
           @content.write(file).should == "{md5}#{Digest::MD5.hexdigest(@source_content)}"
         end
       end
     end
 
     describe "from remote source" do
       before(:each) do
         @resource = Puppet::Type.type(:file).new :path => @filename, :backup => false
         @response = stub_everything 'response', :code => "200"
         @source_content = "source file content"*10000
         @response.stubs(:read_body).multiple_yields(*(["source file content"]*10000))
 
         @conn = stub_everything 'connection'
         @conn.stubs(:request_get).yields(@response)
         Puppet::Network::HttpPool.stubs(:http_instance).returns @conn
 
         @content = @resource.newattr(:content)
         @sourcename = "puppet:///test/foo"
         @source = @resource.newattr(:source)
         @source.stubs(:metadata).returns stub_everything('metadata', :source => @sourcename, :ftype => 'file')
       end
 
       it "should write the contents to the file" do
         @resource.write(@source)
         File.read(@filename).should == @source_content
       end
 
       it "should not write anything if source is not found" do
         @response.stubs(:code).returns("404")
         lambda {@resource.write(@source)}.should raise_error(Net::HTTPError) { |e| e.message =~ /404/ }
         File.read(@filename).should == "initial file content"
       end
 
       it "should raise an HTTP error in case of server error" do
         @response.stubs(:code).returns("500")
         lambda { @content.write(@fh) }.should raise_error { |e| e.message.include? @source_content }
       end
 
       it "should return the checksum computed" do
         File.open(@filename, 'w') do |file|
           @content.write(file).should == "{md5}#{Digest::MD5.hexdigest(@source_content)}"
         end
       end
     end
 
     # These are testing the implementation rather than the desired behaviour; while that bites, there are a whole
     # pile of other methods in the File type that depend on intimate details of this implementation and vice-versa.
     # If these blow up, you are gonna have to review the callers to make sure they don't explode! --daniel 2011-02-01
     describe "each_chunk_from should work" do
       before do
         @content = content.new(:resource => @resource)
       end
 
       it "when content is a string" do
         @content.each_chunk_from('i_am_a_string') { |chunk| chunk.should == 'i_am_a_string' }
       end
 
       # The following manifest is a case where source and content.should are both set
       # file { "/tmp/mydir" :
       #   source  => '/tmp/sourcedir',
       #   recurse => true,
       # }
       it "when content checksum comes from source" do
         source_param = Puppet::Type.type(:file).attrclass(:source)
         source = source_param.new(:resource => @resource)
         @content.should = "{md5}123abcd"
 
         @content.expects(:chunk_file_from_source).returns('from_source')
         @content.each_chunk_from(source) { |chunk| chunk.should == 'from_source' }
       end
 
       it "when no content, source, but ensure present" do
         @resource[:ensure] = :present
         @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       # you might do this if you were just auditing
       it "when no content, source, but ensure file" do
         @resource[:ensure] = :file
         @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       it "when source_or_content is nil and content not a checksum" do
         @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       # the content is munged so that if it's a checksum nil gets passed in
       it "when content is a checksum it should try to read from filebucket" do
         @content.should = "{md5}123abcd"
         @content.expects(:read_file_from_filebucket).once.returns('im_a_filebucket')
         @content.each_chunk_from(nil) { |chunk| chunk.should == 'im_a_filebucket' }
       end
 
       it "when running as puppet apply" do
         @content.class.expects(:standalone?).returns true
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:content).once.returns :whoo
         @content.each_chunk_from(source_or_content) { |chunk| chunk.should == :whoo }
       end
 
       it "when running from source with a local file" do
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:local?).returns true
         @content.expects(:chunk_file_from_disk).with(source_or_content).once.yields 'woot'
         @content.each_chunk_from(source_or_content) { |chunk| chunk.should == 'woot' }
       end
 
       it "when running from source with a remote file" do
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:local?).returns false
         @content.expects(:chunk_file_from_source).with(source_or_content).once.yields 'woot'
         @content.each_chunk_from(source_or_content) { |chunk| chunk.should == 'woot' }
       end
     end
   end
 end
diff --git a/spec/unit/type/file/source_spec.rb b/spec/unit/type/file/source_spec.rb
index efa7c13e6..5129d1e01 100755
--- a/spec/unit/type/file/source_spec.rb
+++ b/spec/unit/type/file/source_spec.rb
@@ -1,276 +1,276 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 source = Puppet::Type.type(:file).attrclass(:source)
 describe Puppet::Type.type(:file).attrclass(:source) do
   include PuppetSpec::Files
 
   before do
     # Wow that's a messy interface to the resource.
     @resource = stub 'resource', :[]= => nil, :property => nil, :catalog => stub("catalog", :dependent_data_expired? => false), :line => 0, :file => ''
     @foobar = make_absolute("/foo/bar")
     @feebooz = make_absolute("/fee/booz")
   end
 
   it "should be a subclass of Parameter" do
     source.superclass.must == Puppet::Parameter
   end
 
   describe "when initializing" do
     it "should fail if the set values are not URLs" do
       s = source.new(:resource => @resource)
       URI.expects(:parse).with('foo').raises RuntimeError
 
       lambda { s.value = %w{foo} }.must raise_error(Puppet::Error)
     end
 
     it "should fail if the URI is not a local file, file URI, or puppet URI" do
       s = source.new(:resource => @resource)
 
       lambda { s.value = %w{http://foo/bar} }.must raise_error(Puppet::Error)
     end
   end
 
   it "should have a method for retrieving its metadata" do
     source.new(:resource => @resource).must respond_to(:metadata)
   end
 
   it "should have a method for setting its metadata" do
     source.new(:resource => @resource).must respond_to(:metadata=)
   end
 
-  describe "when returning the metadata" do
+  describe "when returning the metadata", :fails_on_windows => true do
     before do
       @metadata = stub 'metadata', :source= => nil
     end
 
     it "should return already-available metadata" do
       @source = source.new(:resource => @resource)
       @source.metadata = "foo"
       @source.metadata.should == "foo"
     end
 
     it "should return nil if no @should value is set and no metadata is available" do
       @source = source.new(:resource => @resource)
       @source.metadata.should be_nil
     end
 
     it "should collect its metadata using the Metadata class if it is not already set" do
       @source = source.new(:resource => @resource, :value => @foobar)
       Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar).returns @metadata
       @source.metadata
     end
 
     it "should use the metadata from the first found source" do
       metadata = stub 'metadata', :source= => nil
       @source = source.new(:resource => @resource, :value => [@foobar, @feebooz])
       Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar).returns nil
       Puppet::FileServing::Metadata.indirection.expects(:find).with(@feebooz).returns metadata
       @source.metadata.should equal(metadata)
     end
 
     it "should store the found source as the metadata's source" do
       metadata = mock 'metadata'
       @source = source.new(:resource => @resource, :value => @foobar)
       Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar).returns metadata
 
       metadata.expects(:source=).with(@foobar)
       @source.metadata
     end
 
     it "should fail intelligently if an exception is encountered while querying for metadata" do
       @source = source.new(:resource => @resource, :value => @foobar)
       Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar).raises RuntimeError
 
       @source.expects(:fail).raises ArgumentError
       lambda { @source.metadata }.should raise_error(ArgumentError)
     end
 
     it "should fail if no specified sources can be found" do
       @source = source.new(:resource => @resource, :value => @foobar)
       Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar).returns nil
 
       @source.expects(:fail).raises RuntimeError
 
       lambda { @source.metadata }.should raise_error(RuntimeError)
     end
 
     it "should expire the metadata appropriately" do
       expirer = stub 'expired', :dependent_data_expired? => true
 
       metadata = stub 'metadata', :source= => nil
       Puppet::FileServing::Metadata.indirection.expects(:find).with(@feebooz).returns metadata
 
       @source = source.new(:resource => @resource, :value => [@feebooz])
       @source.metadata = "foo"
 
       @source.stubs(:expirer).returns expirer
 
       @source.metadata.should_not == "foo"
     end
   end
 
   it "should have a method for setting the desired values on the resource" do
     source.new(:resource => @resource).must respond_to(:copy_source_values)
   end
 
   describe "when copying the source values" do
     before do
 
       @resource = Puppet::Type.type(:file).new :path => @foobar
 
       @source = source.new(:resource => @resource)
       @metadata = stub 'metadata', :owner => 100, :group => 200, :mode => 123, :checksum => "{md5}asdfasdf", :ftype => "file"
       @source.stubs(:metadata).returns @metadata
     end
 
     it "should fail if there is no metadata" do
       @source.stubs(:metadata).returns nil
       @source.expects(:devfail).raises ArgumentError
       lambda { @source.copy_source_values }.should raise_error(ArgumentError)
     end
 
     it "should set :ensure to the file type" do
       @metadata.stubs(:ftype).returns "file"
 
       @source.copy_source_values
       @resource[:ensure].must == :file
     end
 
     it "should not set 'ensure' if it is already set to 'absent'" do
       @metadata.stubs(:ftype).returns "file"
 
       @resource[:ensure] = :absent
       @source.copy_source_values
       @resource[:ensure].must == :absent
     end
 
     describe "and the source is a file" do
       before do
         @metadata.stubs(:ftype).returns "file"
       end
 
       it "should copy the metadata's owner, group, checksum, and mode to the resource if they are not set on the resource" do
         Puppet.features.expects(:root?).returns true
 
         @source.copy_source_values
 
         @resource[:owner].must == 100
         @resource[:group].must == 200
         @resource[:mode].must == "173"
 
         # Metadata calls it checksum, we call it content.
         @resource[:content].must == @metadata.checksum
       end
 
       it "should not copy the metadata's owner to the resource if it is already set" do
         @resource[:owner] = 1
         @resource[:group] = 2
         @resource[:mode] = 3
         @resource[:content] = "foobar"
 
         @source.copy_source_values
 
         @resource[:owner].must == 1
         @resource[:group].must == 2
         @resource[:mode].must == "3"
         @resource[:content].should_not == @metadata.checksum
       end
 
       describe "and puppet is not running as root" do
         it "should not try to set the owner" do
           Puppet.features.expects(:root?).returns false
 
           @source.copy_source_values
           @resource[:owner].should be_nil
         end
       end
     end
 
     describe "and the source is a link" do
       it "should set the target to the link destination" do
         @metadata.stubs(:ftype).returns "link"
         @metadata.stubs(:links).returns "manage"
         @resource.stubs(:[])
         @resource.stubs(:[]=)
 
         @metadata.expects(:destination).returns "/path/to/symlink"
 
         @resource.expects(:[]=).with(:target, "/path/to/symlink")
         @source.copy_source_values
       end
     end
   end
 
   it "should have a local? method" do
     source.new(:resource => @resource).must be_respond_to(:local?)
   end
 
   context "when accessing source properties" do
     before(:each) do
       @source = source.new(:resource => @resource)
       @metadata = stub_everything
       @source.stubs(:metadata).returns(@metadata)
     end
 
     describe "for local sources" do
       before(:each) do
         @metadata.stubs(:ftype).returns "file"
         @metadata.stubs(:source).returns("file:///path/to/source")
       end
 
       it "should be local" do
         @source.must be_local
       end
 
       it "should be local if there is no scheme" do
         @metadata.stubs(:source).returns("/path/to/source")
         @source.must be_local
       end
 
       it "should be able to return the metadata source full path" do
         @source.full_path.should == "/path/to/source"
       end
     end
 
     describe "for remote sources" do
       before(:each) do
         @metadata.stubs(:ftype).returns "file"
         @metadata.stubs(:source).returns("puppet://server:8192/path/to/source")
       end
 
       it "should not be local" do
         @source.should_not be_local
       end
 
       it "should be able to return the metadata source full path" do
         @source.full_path.should == "/path/to/source"
       end
 
       it "should be able to return the source server" do
         @source.server.should == "server"
       end
 
       it "should be able to return the source port" do
         @source.port.should == 8192
       end
 
       describe "which don't specify server or port" do
         before(:each) do
           @metadata.stubs(:source).returns("puppet:///path/to/source")
         end
 
         it "should return the default source server" do
           Puppet.settings.expects(:[]).with(:server).returns("myserver")
           @source.server.should == "myserver"
         end
 
         it "should return the default source port" do
           Puppet.settings.expects(:[]).with(:masterport).returns(1234)
           @source.port.should == 1234
         end
       end
     end
   end
 
 end
diff --git a/spec/unit/type/file_spec.rb b/spec/unit/type/file_spec.rb
index c71bdd62a..010b59f78 100755
--- a/spec/unit/type/file_spec.rb
+++ b/spec/unit/type/file_spec.rb
@@ -1,1247 +1,1247 @@
 #!/usr/bin/env rspec
 require '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 autorequire its nearest ancestor directory" do
         file = Puppet::Type::File.new(:path => "/foo/bar/baz")
         dir = Puppet::Type::File.new(:path => "/foo")
         root = Puppet::Type::File.new(:path => "/")
         @catalog.add_resource file
         @catalog.add_resource dir
         @catalog.add_resource root
         reqs = file.autorequire
         reqs.length.must == 1
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire anything when there is no nearest ancestor directory" do
         file = Puppet::Type::File.new(:path => "/foo/bar/baz")
         @catalog.add_resource file
         file.autorequire.should be_empty
       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
 
       it "should accept a double-slash at the start of the path" do
         expect {
           file = Puppet::Type::File.new(:path => "//tmp/xxx")
           # REVISIT: This should be wrong, later.  See the next test.
           # --daniel 2011-01-31
           file[:path].should == '/tmp/xxx'
         }.should_not raise_error
       end
 
       # REVISIT: This is pending, because I don't want to try and audit the
       # entire codebase to make sure we get this right.  POSIX treats two (and
       # exactly two) '/' characters at the start of the path specially.
       #
       # See sections 3.2 and 4.11, which allow DomainOS to be all special like
       # and still have the POSIX branding and all. --daniel 2011-01-31
       it "should preserve the double-slash at the start of the path"
     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", :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 autorequire its nearest ancestor directory" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar/baz")
         dir = Puppet::Type::File.new(:path => "X:/foo")
         root = Puppet::Type::File.new(:path => "X:/")
         @catalog.add_resource file
         @catalog.add_resource dir
         @catalog.add_resource root
         reqs = file.autorequire
         reqs.length.must == 1
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire anything when there is no nearest ancestor directory" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar/baz")
         @catalog.add_resource file
         file.autorequire.should be_empty
       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", :'fails_on_ruby_1.9.2' => true do
         file = Puppet::Type::File.new(:path => "X:/")
         file[:path].should == "X:/"
       end
 
-      it "should add a slash to a drive letter", :'fails_on_ruby_1.9.2' => true do
+      it "should add a slash to a drive letter", :'fails_on_windows' => true, :'fails_on_ruby_1.9.2' => true 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", :if => Puppet.features.microsoft_windows?, :'fails_on_ruby_1.9.2' => true 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 autorequire its nearest ancestor directory" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar/baz/qux")
         dir = Puppet::Type::File.new(:path => "//server/foo/bar")
         root = Puppet::Type::File.new(:path => "//server/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         @catalog.add_resource root
         reqs = file.autorequire
         reqs.length.must == 1
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire anything when there is no nearest ancestor directory" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar/baz/qux")
         @catalog.add_resource file
         file.autorequire.should be_empty
       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 '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.indirection.expects(:search)
       @file.perform_recursion(@file[:path])
     end
 
     it "should use the provided path as the key to the search" do
       Puppet::FileServing::Metadata.indirection.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.indirection.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.indirection.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.indirection.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.indirection.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.indirection.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.indirection.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.indirection.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 specifying both source, and content properties" do
     before do
       @file[:source]  = '/one'
       @file[:content] = 'file contents'
     end
 
     it "should raise an exception" do
       lambda {@file.validate }.should raise_error(/You cannot specify more than one of/)
     end
   end
 
   describe "when using source" do
     before do
       @file[:source]   = '/one'
     end
     Puppet::Type::File::ParameterChecksum.value_collection.values.reject {|v| v == :none}.each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         before do
           @file[:checksum] = checksum_type
         end
 
         it 'should validate' do
 
           lambda { @file.validate }.should_not raise_error
         end
       end
     end
 
     describe "with checksum 'none'" do
       before do
         @file[:checksum] = :none
       end
 
       it 'should raise an exception when validating' do
         lambda { @file.validate }.should raise_error(/You cannot specify source when using checksum 'none'/)
       end
     end
   end
 
   describe "when using content" do
     before do
       @file[:content] = 'file contents'
     end
 
     (Puppet::Type::File::ParameterChecksum.value_collection.values - SOURCE_ONLY_CHECKSUMS).each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         before do
           @file[:checksum] = checksum_type
         end
 
         it 'should validate' do
           lambda { @file.validate }.should_not raise_error
         end
       end
     end
 
     SOURCE_ONLY_CHECKSUMS.each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         it 'should raise an exception when validating' do
           @file[:checksum] = checksum_type
 
           lambda { @file.validate }.should raise_error(/You cannot specify content when using checksum '#{checksum_type}'/)
         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
 
   describe "when auditing" do
     it "should not fail if creating a new file if group is not set" do
       File.exists?(@path).should == false
       file = Puppet::Type::File.new(:name => @path, :audit => "all", :content => "content")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource(file)
 
       Puppet::Util::Storage.stubs(:store) # to prevent the catalog from trying to write state.yaml
       transaction = catalog.apply
 
       transaction.report.resource_statuses["File[#{@path}]"].failed.should == false
       File.exists?(@path).should == true
     end
 
     it "should not log errors if creating a new file with ensure present and no content" do
       File.exists?(@path).should == false
       file = Puppet::Type::File.new(:name => @path, :audit => "content", :ensure => "present")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource(file)
 
       Puppet::Util::Storage.stubs(:store) # to prevent the catalog from trying to write state.yaml
 
       catalog.apply
       @logs.reject {|l| l.level == :notice }.should be_empty
     end
   end
 
   describe "when specifying both source and checksum" do
     it 'should use the specified checksum when source is first' do
       @file[:source] = '/foo'
       @file[:checksum] = :md5lite
 
       @file[:checksum].should be :md5lite
     end
     it 'should use the specified checksum when source is last' do
       @file[:checksum] = :md5lite
       @file[:source] = '/foo'
 
       @file[:checksum].should be :md5lite
     end
   end
 
   describe ".instances" do
     it 'should return an empty array' do
       Puppet::Type::File.instances.should == []
     end
   end
 end
diff --git a/spec/unit/type/group_spec.rb b/spec/unit/type/group_spec.rb
index afe28247a..3b6cac8bc 100755
--- a/spec/unit/type/group_spec.rb
+++ b/spec/unit/type/group_spec.rb
@@ -1,63 +1,63 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type.type(:group) do
+describe Puppet::Type.type(:group), :fails_on_windows => true do
   before do
     ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin" unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
     @class = Puppet::Type.type(:group)
   end
 
   it "should have a default provider" do
     @class.defaultprovider.should_not be_nil
   end
 
   it "should have a default provider inheriting from Puppet::Provider" do
     @class.defaultprovider.ancestors.should be_include(Puppet::Provider)
   end
 
   it "should have a system_groups feature" do
     @class.provider_feature(:system_groups).should_not be_nil
   end
 
   describe "when validating attributes" do
     [:name, :allowdupe].each do |param|
       it "should have a #{param} parameter" do
         @class.attrtype(param).should == :param
       end
     end
 
     [:ensure, :gid].each do |param|
       it "should have a #{param} property" do
         @class.attrtype(param).should == :property
       end
     end
 
     it "should convert gids provided as strings into integers" do
       @class.new(:name => "foo", :gid => "15")[:gid].should == 15
     end
 
     it "should accepts gids provided as integers" do
       @class.new(:name => "foo", :gid => 15)[:gid].should == 15
     end
   end
 
   it "should have a boolean method for determining if duplicates are allowed", :'fails_on_ruby_1.9.2' => true do
     @class.new(:name => "foo").methods.should be_include("allowdupe?")
   end
 
   it "should have a boolean method for determining if system groups are allowed", :'fails_on_ruby_1.9.2' => true do
     @class.new(:name => "foo").methods.should be_include("system?")
   end
 
   it "should call 'create' to create the group" do
     group = @class.new(:name => "foo", :ensure => :present)
     group.provider.expects(:create)
     group.parameter(:ensure).sync
   end
 
   it "should call 'delete' to remove the group" do
     group = @class.new(:name => "foo", :ensure => :absent)
     group.provider.expects(:delete)
     group.parameter(:ensure).sync
   end
 end
diff --git a/spec/unit/type/host_spec.rb b/spec/unit/type/host_spec.rb
index 602c428af..145fb27ab 100755
--- a/spec/unit/type/host_spec.rb
+++ b/spec/unit/type/host_spec.rb
@@ -1,129 +1,129 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 host = Puppet::Type.type(:host)
 
 describe host do
   before do
     @class = host
     @catalog = Puppet::Resource::Catalog.new
     @provider = stub 'provider'
     @resource = stub 'resource', :resource => nil, :provider => @provider
   end
 
   it "should have :name be its namevar" do
     @class.key_attributes.should == [:name]
   end
 
   describe "when validating attributes" do
     [:name, :provider ].each do |param|
       it "should have a #{param} parameter" do
         @class.attrtype(param).should == :param
       end
     end
 
     [:ip, :target, :host_aliases, :comment, :ensure].each do |property|
       it "should have a #{property} property" do
         @class.attrtype(property).should == :property
       end
     end
 
     it "should have a list host_aliases" do
       @class.attrclass(:host_aliases).ancestors.should be_include(Puppet::Property::OrderedList)
     end
 
   end
 
-  describe "when validating values" do
+  describe "when validating values", :fails_on_windows => true do
     it "should support present as a value for ensure" do
       proc { @class.new(:name => "foo", :ensure => :present) }.should_not raise_error
     end
 
     it "should support absent as a value for ensure" do
       proc { @class.new(:name => "foo", :ensure => :absent) }.should_not raise_error
     end
 
     it "should accept IPv4 addresses" do
       proc { @class.new(:name => "foo", :ip => '10.96.0.1') }.should_not raise_error
     end
 
     it "should accept long IPv6 addresses" do
       # Taken from wikipedia article about ipv6
       proc { @class.new(:name => "foo", :ip => '2001:0db8:85a3:08d3:1319:8a2e:0370:7344') }.should_not raise_error
     end
 
     it "should accept one host_alias" do
       proc { @class.new(:name => "foo", :host_aliases => 'alias1') }.should_not raise_error
     end
 
     it "should accept multiple host_aliases" do
       proc { @class.new(:name => "foo", :host_aliases => [ 'alias1', 'alias2' ]) }.should_not raise_error
     end
 
     it "should accept shortened IPv6 addresses" do
       proc { @class.new(:name => "foo", :ip => '2001:db8:0:8d3:0:8a2e:70:7344') }.should_not raise_error
       proc { @class.new(:name => "foo", :ip => '::ffff:192.0.2.128') }.should_not raise_error
       proc { @class.new(:name => "foo", :ip => '::1') }.should_not raise_error
     end
 
     it "should not accept malformed IPv4 addresses like 192.168.0.300" do
       proc { @class.new(:name => "foo", :ip => '192.168.0.300') }.should raise_error
     end
 
     it "should not accept malformed IP addresses like 2001:0dg8:85a3:08d3:1319:8a2e:0370:7344" do
       proc { @class.new(:name => "foo", :ip => '2001:0dg8:85a3:08d3:1319:8a2e:0370:7344') }.should raise_error
     end
 
     it "should not accept spaces in resourcename" do
       proc { @class.new(:name => "foo bar") }.should raise_error
     end
 
     it "should not accept host_aliases with spaces" do
       proc { @class.new(:name => "foo", :host_aliases => [ 'well_formed', 'not wellformed' ]) }.should raise_error
     end
 
     it "should not accept empty host_aliases" do
       proc { @class.new(:name => "foo", :host_aliases => ['alias1','']) }.should raise_error
     end
   end
 
   describe "when syncing" do
 
     it "should send the first value to the provider for ip property" do
       @ip = @class.attrclass(:ip).new(:resource => @resource, :should => %w{192.168.0.1 192.168.0.2})
       @provider.expects(:ip=).with '192.168.0.1'
       @ip.sync
     end
 
     it "should send the first value to the provider for comment property" do
       @comment = @class.attrclass(:comment).new(:resource => @resource, :should => %w{Bazinga Notme})
       @provider.expects(:comment=).with 'Bazinga'
       @comment.sync
     end
 
     it "should send the joined array to the provider for host_alias" do
       @host_aliases = @class.attrclass(:host_aliases).new(:resource => @resource, :should => %w{foo bar})
       @provider.expects(:host_aliases=).with 'foo bar'
       @host_aliases.sync
     end
 
     it "should also use the specified delimiter for joining" do
       @host_aliases = @class.attrclass(:host_aliases).new(:resource => @resource, :should => %w{foo bar})
       @host_aliases.stubs(:delimiter).returns "\t"
       @provider.expects(:host_aliases=).with "foo\tbar"
       @host_aliases.sync
     end
 
     it "should care about the order of host_aliases" do
       @host_aliases = @class.attrclass(:host_aliases).new(:resource => @resource, :should => %w{foo bar})
       @host_aliases.insync?(%w{foo bar}).should == true
       @host_aliases.insync?(%w{bar foo}).should == false
     end
 
     it "should not consider aliases to be in sync if should is a subset of current" do
       @host_aliases = @class.attrclass(:host_aliases).new(:resource => @resource, :should => %w{foo bar})
       @host_aliases.insync?(%w{foo bar anotherone}).should == false
     end
 
   end
 end
diff --git a/spec/unit/type/mount_spec.rb b/spec/unit/type/mount_spec.rb
index 9ef76992a..3309cd267 100755
--- a/spec/unit/type/mount_spec.rb
+++ b/spec/unit/type/mount_spec.rb
@@ -1,329 +1,329 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type.type(:mount) do
+describe Puppet::Type.type(:mount), :fails_on_windows => true do
   it "should have a :refreshable feature that requires the :remount method" do
     Puppet::Type.type(:mount).provider_feature(:refreshable).methods.should == [:remount]
   end
 
   it "should have no default value for :ensure" do
     mount = Puppet::Type.type(:mount).new(:name => "yay")
     mount.should(:ensure).should be_nil
   end
 
   it "should have :name as the only keyattribut" do
     Puppet::Type.type(:mount).key_attributes.should == [:name]
   end
 end
 
-describe Puppet::Type.type(:mount), "when validating attributes" do
+describe Puppet::Type.type(:mount), "when validating attributes", :fails_on_windows => true do
   [:name, :remounts, :provider].each do |param|
     it "should have a #{param} parameter" do
       Puppet::Type.type(:mount).attrtype(param).should == :param
     end
   end
 
   [:ensure, :device, :blockdevice, :fstype, :options, :pass, :dump, :atboot, :target].each do |param|
     it "should have a #{param} property" do
       Puppet::Type.type(:mount).attrtype(param).should == :property
     end
   end
 end
 
-describe Puppet::Type.type(:mount)::Ensure, "when validating values" do
+describe Puppet::Type.type(:mount)::Ensure, "when validating values", :fails_on_windows => true do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil
     Puppet::Type.type(:mount).defaultprovider.expects(:new).returns(@provider)
   end
 
   it "should alias :present to :defined as a value to :ensure" do
     mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :present)
     mount.should(:ensure).should == :defined
   end
 
   it "should support :present as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :present)
   end
 
   it "should support :defined as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :defined)
   end
 
   it "should support :unmounted as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :unmounted)
   end
 
   it "should support :absent as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :absent)
   end
 
   it "should support :mounted as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
   end
 end
 
-describe Puppet::Type.type(:mount)::Ensure do
+describe Puppet::Type.type(:mount)::Ensure, :fails_on_windows => true do
   before :each do
     provider_properties = {}
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :property_hash => provider_properties
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
     @mount = Puppet::Type.type(:mount).new(:name => "yay", :check => :ensure)
 
     @ensure = @mount.property(:ensure)
   end
 
   def mount_stub(params)
     Puppet::Type.type(:mount).validproperties.each do |prop|
       unless params[prop]
         params[prop] = :absent
         @mount[prop] = :absent
       end
     end
 
     params.each do |param, value|
       @provider.stubs(param).returns(value)
     end
   end
 
   describe Puppet::Type.type(:mount)::Ensure, "when changing the host" do
 
     def test_ensure_change(options)
       @provider.stubs(:get).with(:ensure).returns options[:from]
       @provider.stubs(:ensure).returns options[:from]
       @provider.stubs(:mounted?).returns([:mounted,:ghost].include? options[:from])
       @provider.expects(:create).times(options[:create] || 0)
       @provider.expects(:destroy).times(options[:destroy] || 0)
       @provider.expects(:mount).never
       @provider.expects(:unmount).times(options[:unmount] || 0)
       @ensure.stubs(:syncothers)
       @ensure.should = options[:to]
       @ensure.sync
       (!!@provider.property_hash[:needs_mount]).should == (!!options[:mount])
    end
 
    it "should create itself when changing from :ghost to :present" do
      test_ensure_change(:from => :ghost, :to => :present, :create => 1)
    end
 
    it "should create itself when changing from :absent to :present" do
      test_ensure_change(:from => :absent, :to => :present, :create => 1)
    end
 
    it "should create itself and unmount when changing from :ghost to :unmounted" do
      test_ensure_change(:from => :ghost, :to => :unmounted, :create => 1, :unmount => 1)
    end
 
    it "should unmount resource when changing from :mounted to :unmounted" do
      test_ensure_change(:from => :mounted, :to => :unmounted, :unmount => 1)
    end
 
    it "should create itself when changing from :absent to :unmounted" do
      test_ensure_change(:from => :absent, :to => :unmounted, :create => 1)
    end
 
    it "should unmount resource when changing from :ghost to :absent" do
      test_ensure_change(:from => :ghost, :to => :absent, :unmount => 1)
    end
 
    it "should unmount and destroy itself when changing from :mounted to :absent" do
      test_ensure_change(:from => :mounted, :to => :absent, :destroy => 1, :unmount => 1)
    end
 
    it "should destroy itself when changing from :unmounted to :absent" do
      test_ensure_change(:from => :unmounted, :to => :absent, :destroy => 1)
    end
 
    it "should create itself when changing from :ghost to :mounted" do
      test_ensure_change(:from => :ghost, :to => :mounted, :create => 1)
    end
 
    it "should create itself and mount when changing from :absent to :mounted" do
      test_ensure_change(:from => :absent, :to => :mounted, :create => 1, :mount => 1)
    end
 
    it "should mount resource when changing from :unmounted to :mounted" do
      test_ensure_change(:from => :unmounted, :to => :mounted, :mount => 1)
    end
 
 
    it "should be in sync if it is :absent and should be :absent" do
      @ensure.should = :absent
      @ensure.safe_insync?(:absent).should == true
    end
 
    it "should be out of sync if it is :absent and should be :defined" do
      @ensure.should = :defined
      @ensure.safe_insync?(:absent).should == false
    end
 
    it "should be out of sync if it is :absent and should be :mounted" do
      @ensure.should = :mounted
      @ensure.safe_insync?(:absent).should == false
    end
 
    it "should be out of sync if it is :absent and should be :unmounted" do
      @ensure.should = :unmounted
      @ensure.safe_insync?(:absent).should == false
    end
 
    it "should be out of sync if it is :mounted and should be :absent" do
      @ensure.should = :absent
      @ensure.safe_insync?(:mounted).should == false
    end
 
    it "should be in sync if it is :mounted and should be :defined" do
      @ensure.should = :defined
      @ensure.safe_insync?(:mounted).should == true
    end
 
    it "should be in sync if it is :mounted and should be :mounted" do
      @ensure.should = :mounted
      @ensure.safe_insync?(:mounted).should == true
    end
 
    it "should be out in sync if it is :mounted and should be :unmounted" do
      @ensure.should = :unmounted
      @ensure.safe_insync?(:mounted).should == false
    end
 
 
    it "should be out of sync if it is :unmounted and should be :absent" do
      @ensure.should = :absent
      @ensure.safe_insync?(:unmounted).should == false
    end
 
    it "should be in sync if it is :unmounted and should be :defined" do
      @ensure.should = :defined
      @ensure.safe_insync?(:unmounted).should == true
    end
 
    it "should be out of sync if it is :unmounted and should be :mounted" do
      @ensure.should = :mounted
      @ensure.safe_insync?(:unmounted).should == false
    end
 
    it "should be in sync if it is :unmounted and should be :unmounted" do
      @ensure.should = :unmounted
      @ensure.safe_insync?(:unmounted).should == true
    end
 
 
    it "should be out of sync if it is :ghost and should be :absent" do
      @ensure.should = :absent
      @ensure.safe_insync?(:ghost).should == false
    end
 
    it "should be out of sync if it is :ghost and should be :defined" do
      @ensure.should = :defined
      @ensure.safe_insync?(:ghost).should == false
    end
 
    it "should be out of sync if it is :ghost and should be :mounted" do
      @ensure.should = :mounted
      @ensure.safe_insync?(:ghost).should == false
    end
 
    it "should be out of sync if it is :ghost and should be :unmounted" do
      @ensure.should = :unmounted
      @ensure.safe_insync?(:ghost).should == false
    end
 
  end
 
   describe Puppet::Type.type(:mount), "when responding to refresh" do
     pending "2.6.x specifies slightly different behavior and the desired behavior needs to be clarified and revisited.  See ticket #4904" do
 
       it "should remount if it is supposed to be mounted" do
         @mount[:ensure] = "mounted"
         @provider.expects(:remount)
 
         @mount.refresh
       end
 
       it "should not remount if it is supposed to be present" do
         @mount[:ensure] = "present"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
 
       it "should not remount if it is supposed to be absent" do
         @mount[:ensure] = "absent"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
 
       it "should not remount if it is supposed to be defined" do
         @mount[:ensure] = "defined"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
 
       it "should not remount if it is supposed to be unmounted" do
         @mount[:ensure] = "unmounted"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
 
       it "should not remount swap filesystems" do
         @mount[:ensure] = "mounted"
         @mount[:fstype] = "swap"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
     end
   end
 end
 
-describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
+describe Puppet::Type.type(:mount), "when modifying an existing mount entry", :fails_on_windows => true do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :remount => nil
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
     @mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
 
     {:device => "/foo/bar", :blockdevice => "/other/bar", :target => "/what/ever", :fstype => 'eh', :options => "", :pass => 0, :dump => 0, :atboot => 0,
       :ensure => :mounted}.each do
       |param, value|
       @mount.provider.stubs(param).returns value
       @mount[param] = value
     end
 
     @mount.provider.stubs(:mounted?).returns true
 
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
 
     @catalog = Puppet::Resource::Catalog.new
     @catalog.add_resource @mount
   end
 
   it "should use the provider to change the dump value" do
     @mount.provider.expects(:dump).returns 0
     @mount.provider.expects(:dump=).with(1)
 
     @mount[:dump] = 1
 
     @catalog.apply
   end
 
   it "should umount before flushing changes to disk" do
     syncorder = sequence('syncorder')
     @mount.provider.expects(:options).returns 'soft'
     @mount.provider.expects(:ensure).returns :mounted
 
     @mount.provider.expects(:unmount).in_sequence(syncorder)
     @mount.provider.expects(:options=).in_sequence(syncorder).with 'hard'
     @mount.expects(:flush).in_sequence(syncorder) # Call inside syncothers
     @mount.expects(:flush).in_sequence(syncorder) # I guess transaction or anything calls flush again
 
     @mount[:ensure] = :unmounted
     @mount[:options] = 'hard'
 
     @catalog.apply
   end
 
 end
diff --git a/spec/unit/type/resources_spec.rb b/spec/unit/type/resources_spec.rb
index 48c068cfa..5e9396b24 100755
--- a/spec/unit/type/resources_spec.rb
+++ b/spec/unit/type/resources_spec.rb
@@ -1,101 +1,101 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 resources = Puppet::Type.type(:resources)
 
 # There are still plenty of tests to port over from test/.
 describe resources do
   describe "when initializing" do
     it "should fail if the specified resource type does not exist" do
       Puppet::Type.stubs(:type).with { |x| x.to_s.downcase == "resources"}.returns resources
       Puppet::Type.expects(:type).with("nosuchtype").returns nil
       lambda { resources.new :name => "nosuchtype" }.should raise_error(Puppet::Error)
     end
 
     it "should not fail when the specified resource type exists" do
       lambda { resources.new :name => "file" }.should_not raise_error
     end
 
     it "should set its :resource_type attribute" do
       resources.new(:name => "file").resource_type.should == Puppet::Type.type(:file)
     end
   end
 
-  describe "#generate" do
+  describe "#generate", :fails_on_windows => true do
     before do
       @host1 = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
       @catalog = Puppet::Resource::Catalog.new
       @context = Puppet::Transaction.new(@catalog)
     end
 
       describe "when dealing with non-purging resources" do
         before do
           @resources = Puppet::Type.type(:resources).new(:name => 'host')
         end
 
         it "should not generate any resource" do
           @resources.generate.should be_empty
         end
       end
 
       describe "when the catalog contains a purging resource" do
         before do
           @resources = Puppet::Type.type(:resources).new(:name => 'host', :purge => true)
           @purgeable_resource = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
           @catalog.add_resource @resources
         end
 
         it "should not generate a duplicate of that resource" do
           Puppet::Type.type(:host).stubs(:instances).returns [@host1]
           @catalog.add_resource @host1
           @resources.generate.collect { |r| r.ref }.should_not include(@host1.ref)
         end
 
         it "should not include the skipped users", :'fails_on_ruby_1.9.2' => true do
           res = Puppet::Type.type(:resources).new :name => :user, :purge => true
           res.catalog = Puppet::Resource::Catalog.new
 
           users = [
             Puppet::Type.type(:user).new(:name => "root")
           ]
           Puppet::Type.type(:user).expects(:instances).returns users
           list = res.generate
 
           names = list.collect { |r| r[:name] }
           names.should_not be_include("root")
         end
 
         describe "when generating a purgeable resource" do
           it "should be included in the generated resources" do
             Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
             @resources.generate.collect { |r| r.ref }.should include(@purgeable_resource.ref)
           end
         end
 
         describe "when the instance's do not have an ensure property" do
           it "should not be included in the generated resources" do
             @no_ensure_resource = Puppet::Type.type(:exec).new(:name => '/usr/bin/env echo')
             Puppet::Type.type(:host).stubs(:instances).returns [@no_ensure_resource]
             @resources.generate.collect { |r| r.ref }.should_not include(@no_ensure_resource.ref)
           end
         end
 
         describe "when the instance's ensure property does not accept absent" do
           it "should not be included in the generated resources" do
             @no_absent_resource = Puppet::Type.type(:service).new(:name => 'foobar')
             Puppet::Type.type(:host).stubs(:instances).returns [@no_absent_resource]
             @resources.generate.collect { |r| r.ref }.should_not include(@no_absent_resource.ref)
           end
         end
 
         describe "when checking the instance fails" do
           it "should not be included in the generated resources" do
             @purgeable_resource = Puppet::Type.type(:host).new(:name => 'foobar')
             Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
             @resources.expects(:check).with(@purgeable_resource).returns(false)
             @resources.generate.collect { |r| r.ref }.should_not include(@purgeable_resource.ref)
           end
         end
       end
   end
 end
diff --git a/spec/unit/type/user_spec.rb b/spec/unit/type/user_spec.rb
index 823b12f27..f24fc8eef 100755
--- a/spec/unit/type/user_spec.rb
+++ b/spec/unit/type/user_spec.rb
@@ -1,343 +1,343 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 user = Puppet::Type.type(:user)
 
-describe user do
+describe user, :fails_on_windows => true do
   before do
     ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin" unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
     @provider = stub 'provider'
     @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
   end
 
   it "should have a default provider inheriting from Puppet::Provider" do
     user.defaultprovider.ancestors.should be_include(Puppet::Provider)
   end
 
   it "should be able to create a instance" do
     user.new(:name => "foo").should_not be_nil
   end
 
   it "should have an allows_duplicates feature" do
     user.provider_feature(:allows_duplicates).should_not be_nil
   end
 
   it "should have an manages_homedir feature" do
     user.provider_feature(:manages_homedir).should_not be_nil
   end
 
   it "should have an manages_passwords feature" do
     user.provider_feature(:manages_passwords).should_not be_nil
   end
 
   it "should have a manages_solaris_rbac feature" do
     user.provider_feature(:manages_solaris_rbac).should_not be_nil
   end
 
   it "should have a manages_expiry feature" do
     user.provider_feature(:manages_expiry).should_not be_nil
   end
 
   it "should have a manages_password_age feature" do
     user.provider_feature(:manages_password_age).should_not be_nil
   end
 
   it "should have a system_users feature" do
     user.provider_feature(:system_users).should_not be_nil
   end
 
   describe "instances" do
     it "should have a valid provider" do
       user.new(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
     end
 
     it "should delegate existence questions to its provider" do
       instance = user.new(:name => "foo")
       instance.provider.expects(:exists?).returns "eh"
       instance.exists?.should == "eh"
     end
   end
 
   properties = [:ensure, :uid, :gid, :home, :comment, :shell, :password, :password_min_age, :password_max_age, :groups, :roles, :auths, :profiles, :project, :keys, :expiry]
 
   properties.each do |property|
     it "should have a #{property} property" do
       user.attrclass(property).ancestors.should be_include(Puppet::Property)
     end
 
     it "should have documentation for its #{property} property" do
       user.attrclass(property).doc.should be_instance_of(String)
     end
   end
 
   list_properties = [:groups, :roles, :auths]
 
   list_properties.each do |property|
     it "should have a list '#{property}'" do
       user.attrclass(property).ancestors.should be_include(Puppet::Property::List)
     end
   end
 
   it "should have an ordered list 'profiles'" do
     user.attrclass(:profiles).ancestors.should be_include(Puppet::Property::OrderedList)
   end
 
   it "should have key values 'keys'" do
     user.attrclass(:keys).ancestors.should be_include(Puppet::Property::KeyValue)
   end
 
   describe "when retrieving all current values" do
     before do
       @user = user.new(:name => "foo", :uid => 10)
     end
 
     it "should return a hash containing values for all set properties" do
       @user[:gid] = 10
       @user.property(:ensure).expects(:retrieve).returns :present
       @user.property(:uid).expects(:retrieve).returns 15
       @user.property(:gid).expects(:retrieve).returns 15
       values = @user.retrieve
       [@user.property(:uid), @user.property(:gid)].each { |property| values.should be_include(property) }
     end
 
     it "should set all values to :absent if the user is absent" do
       @user.property(:ensure).expects(:retrieve).returns :absent
       @user.property(:uid).expects(:retrieve).never
       @user.retrieve[@user.property(:uid)].should == :absent
     end
 
     it "should include the result of retrieving each property's current value if the user is present" do
       @user.property(:ensure).expects(:retrieve).returns :present
       @user.property(:uid).expects(:retrieve).returns 15
       @user.retrieve[@user.property(:uid)].should == 15
     end
   end
 
   describe "when managing the ensure property" do
     before do
       @ensure = user.attrclass(:ensure).new(:resource => @resource)
     end
 
     it "should support a :present value" do
       lambda { @ensure.should = :present }.should_not raise_error
     end
 
     it "should support an :absent value" do
       lambda { @ensure.should = :absent }.should_not raise_error
     end
 
     it "should call :create on the provider when asked to sync to the :present state" do
       @provider.expects(:create)
       @ensure.should = :present
       @ensure.sync
     end
 
     it "should call :delete on the provider when asked to sync to the :absent state" do
       @provider.expects(:delete)
       @ensure.should = :absent
       @ensure.sync
     end
 
     describe "and determining the current state" do
       it "should return :present when the provider indicates the user exists" do
         @provider.expects(:exists?).returns true
         @ensure.retrieve.should == :present
       end
 
       it "should return :absent when the provider indicates the user does not exist" do
         @provider.expects(:exists?).returns false
         @ensure.retrieve.should == :absent
       end
     end
   end
 
   describe "when managing the uid property" do
     it "should convert number-looking strings into actual numbers" do
       uid = user.attrclass(:uid).new(:resource => @resource)
       uid.should = "50"
       uid.should.must == 50
     end
 
     it "should support UIDs as numbers" do
       uid = user.attrclass(:uid).new(:resource => @resource)
       uid.should = 50
       uid.should.must == 50
     end
 
     it "should :absent as a value" do
       uid = user.attrclass(:uid).new(:resource => @resource)
       uid.should = :absent
       uid.should.must == :absent
     end
   end
 
   describe "when managing the gid" do
     it "should :absent as a value" do
       gid = user.attrclass(:gid).new(:resource => @resource)
       gid.should = :absent
       gid.should.must == :absent
     end
 
     it "should convert number-looking strings into actual numbers" do
       gid = user.attrclass(:gid).new(:resource => @resource)
       gid.should = "50"
       gid.should.must == 50
     end
 
     it "should support GIDs specified as integers" do
       gid = user.attrclass(:gid).new(:resource => @resource)
       gid.should = 50
       gid.should.must == 50
     end
 
     it "should support groups specified by name" do
       gid = user.attrclass(:gid).new(:resource => @resource)
       gid.should = "foo"
       gid.should.must == "foo"
     end
 
     describe "when testing whether in sync" do
       before do
         @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
       end
 
       it "should return true if no 'should' values are set" do
         @gid = user.attrclass(:gid).new(:resource => @resource)
 
         @gid.must be_safe_insync(500)
       end
 
       it "should return true if any of the specified groups are equal to the current integer" do
         Puppet::Util.expects(:gid).with("foo").returns 300
         Puppet::Util.expects(:gid).with("bar").returns 500
 
         @gid.must be_safe_insync(500)
       end
 
       it "should return false if none of the specified groups are equal to the current integer" do
         Puppet::Util.expects(:gid).with("foo").returns 300
         Puppet::Util.expects(:gid).with("bar").returns 500
 
         @gid.should_not be_safe_insync(700)
       end
     end
 
     describe "when syncing" do
       before do
         @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
       end
 
       it "should use the first found, specified group as the desired value and send it to the provider" do
         Puppet::Util.expects(:gid).with("foo").returns nil
         Puppet::Util.expects(:gid).with("bar").returns 500
 
         @provider.expects(:gid=).with 500
 
         @gid.sync
       end
     end
   end
 
   describe "when managing expiry" do
     before do
       @expiry = user.attrclass(:expiry).new(:resource => @resource)
     end
 
     it "should fail if given an invalid date" do
       lambda { @expiry.should = "200-20-20" }.should raise_error(Puppet::Error)
     end
   end
 
   describe "when managing minimum password age" do
     before do
       @age = user.attrclass(:password_min_age).new(:resource => @resource)
     end
 
     it "should accept a negative minimum age" do
       expect { @age.should = -1 }.should_not raise_error
     end
 
     it "should fail with an empty minimum age" do
       expect { @age.should = '' }.should raise_error(Puppet::Error)
     end
   end
 
   describe "when managing maximum password age" do
     before do
       @age = user.attrclass(:password_max_age).new(:resource => @resource)
     end
 
     it "should accept a negative maximum age" do
       expect { @age.should = -1 }.should_not raise_error
     end
 
     it "should fail with an empty maximum age" do
       expect { @age.should = '' }.should raise_error(Puppet::Error)
     end
   end
 
   describe "when managing passwords" do
     before do
       @password = user.attrclass(:password).new(:resource => @resource, :should => "mypass")
     end
 
     it "should not include the password in the change log when adding the password" do
       @password.change_to_s(:absent, "mypass").should_not be_include("mypass")
     end
 
     it "should not include the password in the change log when changing the password" do
       @password.change_to_s("other", "mypass").should_not be_include("mypass")
     end
 
     it "should redact the password when displaying the old value" do
       @password.is_to_s("currentpassword").should =~ /^\[old password hash redacted\]$/
     end
 
     it "should redact the password when displaying the new value" do
       @password.should_to_s("newpassword").should =~ /^\[new password hash redacted\]$/
     end
 
     it "should fail if a ':' is included in the password" do
       lambda { @password.should = "some:thing" }.should raise_error(Puppet::Error)
     end
 
     it "should allow the value to be set to :absent" do
       lambda { @password.should = :absent }.should_not raise_error
     end
   end
 
   describe "when manages_solaris_rbac is enabled" do
     before do
       @provider.stubs(:satisfies?).returns(false)
       @provider.expects(:satisfies?).with([:manages_solaris_rbac]).returns(true)
     end
 
     it "should support a :role value for ensure" do
       @ensure = user.attrclass(:ensure).new(:resource => @resource)
       lambda { @ensure.should = :role }.should_not raise_error
     end
   end
 
   describe "when user has roles" do
     before do
       # To test this feature, we have to support it.
       user.new(:name => "foo").provider.class.stubs(:feature?).returns(true)
     end
 
     it "should autorequire roles" do
       testuser = Puppet::Type.type(:user).new(:name => "testuser")
       testuser[:roles] = "testrole"
 
       testrole = Puppet::Type.type(:user).new(:name => "testrole")
 
       config = Puppet::Resource::Catalog.new :testing do |conf|
         [testuser, testrole].each { |resource| conf.add_resource resource }
       end
       Puppet::Type::User::ProviderDirectoryservice.stubs(:get_macosx_version_major).returns "10.5"
 
       rel = testuser.autorequire[0]
       rel.source.ref.should == testrole.ref
       rel.target.ref.should == testuser.ref
     end
   end
 end
diff --git a/spec/unit/util/execution_stub_spec.rb b/spec/unit/util/execution_stub_spec.rb
index 34987689c..9cd15ca6a 100755
--- a/spec/unit/util/execution_stub_spec.rb
+++ b/spec/unit/util/execution_stub_spec.rb
@@ -1,34 +1,34 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Util::ExecutionStub do
   it "should use the provided stub code when 'set' is called" do
     Puppet::Util::ExecutionStub.set do |command, options|
       command.should == ['/bin/foo', 'bar']
       "stub output"
     end
     Puppet::Util::ExecutionStub.current_value.should_not == nil
     Puppet::Util.execute(['/bin/foo', 'bar']).should == "stub output"
   end
 
   it "should automatically restore normal execution at the conclusion of each spec test" do
     # Note: this test relies on the previous test creating a stub.
     Puppet::Util::ExecutionStub.current_value.should == nil
   end
 
-  it "should restore normal execution after 'reset' is called" do
+  it "should restore normal execution after 'reset' is called", :fails_on_windows => true do
     true_command = Puppet::Util.which('true') # Note: "true" exists at different paths in different OSes
     stub_call_count = 0
     Puppet::Util::ExecutionStub.set do |command, options|
       command.should == [true_command]
       stub_call_count += 1
       'stub called'
     end
     Puppet::Util.execute([true_command]).should == 'stub called'
     stub_call_count.should == 1
     Puppet::Util::ExecutionStub.reset
     Puppet::Util::ExecutionStub.current_value.should == nil
     Puppet::Util.execute([true_command]).should == ''
     stub_call_count.should == 1
   end
 end
diff --git a/spec/unit/util/logging_spec.rb b/spec/unit/util/logging_spec.rb
index 6a77e70ef..2953f54a4 100755
--- a/spec/unit/util/logging_spec.rb
+++ b/spec/unit/util/logging_spec.rb
@@ -1,119 +1,119 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/logging'
 
 class LoggingTester
   include Puppet::Util::Logging
 end
 
 describe Puppet::Util::Logging do
   before do
     @logger = LoggingTester.new
   end
 
   Puppet::Util::Log.eachlevel do |level|
     it "should have a method for sending '#{level}' logs" do
       @logger.should respond_to(level)
     end
   end
 
   it "should have a method for sending a log with a specified log level" do
     @logger.expects(:to_s).returns "I'm a string!"
     Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" and args[:level] == "loglevel" and args[:message] == "mymessage" }
 
     @logger.send_log "loglevel", "mymessage"
   end
 
   describe "when sending a log" do
     it "should use the Log's 'create' entrance method" do
       Puppet::Util::Log.expects(:create)
 
       @logger.notice "foo"
     end
 
     it "should send itself converted to a string as the log source" do
       @logger.expects(:to_s).returns "I'm a string!"
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" }
 
       @logger.notice "foo"
     end
 
     it "should queue logs sent without a specified destination" do
       Puppet::Util::Log.close_all
       Puppet::Util::Log.expects(:queuemessage)
 
       @logger.notice "foo"
     end
 
-    it "should use the path of any provided resource type" do
+    it "should use the path of any provided resource type", :fails_on_windows => true do
       resource = Puppet::Type.type(:mount).new :name => "foo"
 
       resource.expects(:path).returns "/path/to/mount".to_sym
 
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/mount" }
 
       resource.notice "foo"
     end
 
-    it "should use the path of any provided resource parameter" do
+    it "should use the path of any provided resource parameter", :fails_on_windows => true do
       resource = Puppet::Type.type(:mount).new :name => "foo"
 
       param = resource.parameter(:name)
 
       param.expects(:path).returns "/path/to/param".to_sym
 
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/param" }
 
       param.notice "foo"
     end
 
     it "should send the provided argument as the log message" do
       Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo" }
 
       @logger.notice "foo"
     end
 
     it "should join any provided arguments into a single string for the message" do
       Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo bar baz" }
 
       @logger.notice ["foo", "bar", "baz"]
     end
 
     [:file, :line, :tags].each do |attr|
       it "should include #{attr} if available" do
         @logger.singleton_class.send(:attr_accessor, attr)
 
         @logger.send(attr.to_s + "=", "myval")
 
         Puppet::Util::Log.expects(:create).with { |args| args[attr] == "myval" }
         @logger.notice "foo"
       end
     end
   end
 
   describe "when sending a deprecation warning" do
     before do
       @logger.clear_deprecation_warnings
     end
 
     it "should the message with warn" do
       @logger.expects(:warning).with('foo')
       @logger.deprecation_warning 'foo'
     end
 
     it "should only log each unique message once" do
       @logger.expects(:warning).with('foo').once
       5.times { @logger.deprecation_warning 'foo' }
     end
 
     it "should only log the first 100 messages" do
       (1..100).each { |i|
           @logger.expects(:warning).with(i).once
           @logger.deprecation_warning i
       }
       @logger.expects(:warning).with(101).never
       @logger.deprecation_warning 101
     end
   end
 end
diff --git a/spec/unit/util/run_mode_spec.rb b/spec/unit/util/run_mode_spec.rb
index c8d2b31f6..883ee1206 100755
--- a/spec/unit/util/run_mode_spec.rb
+++ b/spec/unit/util/run_mode_spec.rb
@@ -1,50 +1,50 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Util::RunMode do
+describe Puppet::Util::RunMode, :fails_on_windows => true do
   before do
     @run_mode = Puppet::Util::RunMode.new('fake')
   end
 
   it "should have confdir /etc/puppet when run as root" do
     Puppet.features.stubs(:root?).returns(true)
     @run_mode.conf_dir.should == '/etc/puppet'
   end
 
   it "should have confdir ~/.puppet when run as non-root" do
     Puppet.features.stubs(:root?).returns(false)
     @run_mode.expects(:expand_path).with("~/.puppet").returns("~/.puppet")
     @run_mode.conf_dir.should == "~/.puppet"
   end
 
   it "should have vardir /var/lib/puppet when run as root" do
     Puppet.features.stubs(:root?).returns(true)
     @run_mode.var_dir.should == '/var/lib/puppet'
   end
 
   it "should have vardir ~/.puppet/var when run as non-root" do
     Puppet.features.stubs(:root?).returns(false)
     @run_mode.expects(:expand_path).with("~/.puppet/var").returns("~/.puppet/var")
     @run_mode.var_dir.should == "~/.puppet/var"
   end
 
   it "should have rundir depend on vardir" do
     @run_mode.run_dir.should == '$vardir/run'
   end
 
   it "should have logopts return an array with $vardir/log if runmode is not master" do
     @run_mode.expects(:master?).returns false
     @run_mode.logopts.should == ["$vardir/log", "The Puppet log directory."]
   end
 
   it "should have logopts return a hash with $vardir/log and other metadata if runmode is master" do
     @run_mode.expects(:master?).returns true
     @run_mode.logopts.should == {
       :default => "$vardir/log",
       :mode    => 0750,
       :owner   => "service",
       :group   => "service",
       :desc    => "The Puppet log directory.",
     }
   end
 end