diff --git a/spec/integration/parser/ruby_manifest_spec.rb b/spec/integration/parser/ruby_manifest_spec.rb
index b04baf5e0..7f3bb71e9 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", :fails_on_windows => true do
+describe "Pure ruby manifests" 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/resource/type_collection_spec.rb b/spec/integration/resource/type_collection_spec.rb
index 0852a9850..6ea2e7fe7 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, :fails_on_windows => true do
+describe Puppet::Resource::TypeCollection 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/unit/indirector/file_bucket_file/file_spec.rb b/spec/unit/indirector/file_bucket_file/file_spec.rb
index ee0b61af1..eb86eee85 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", :fails_on_windows => true do
+  describe "non-stubbing tests" 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