diff --git a/spec/integration/network/server/webrick_spec.rb b/spec/integration/network/server/webrick_spec.rb
index 2390fcab1..7365462d3 100755
--- a/spec/integration/network/server/webrick_spec.rb
+++ b/spec/integration/network/server/webrick_spec.rb
@@ -1,85 +1,83 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/network/server'
 require 'puppet/ssl/certificate_authority'
 require 'socket'
 
-describe Puppet::Network::Server do
+describe Puppet::Network::Server, :unless => Puppet.features.microsoft_windows? do
+  include PuppetSpec::Files
+
   describe "when using webrick" do
     before :each do
       Puppet[:servertype] = 'webrick'
       Puppet[:server] = '127.0.0.1'
       @params = { :port => 34343, :handlers => [ :node ], :xmlrpc_handlers => [ :status ] }
 
       # Get a safe temporary file
-      @tmpfile = Tempfile.new("webrick_integration_testing")
-      @dir = @tmpfile.path + "_dir"
+      dir = tmpdir("webrick_integration_testing")
 
-      Puppet.settings[:confdir] = @dir
-      Puppet.settings[:vardir] = @dir
+      Puppet.settings[:confdir] = dir
+      Puppet.settings[:vardir] = dir
       Puppet.settings[:group] = Process.gid
 
       Puppet::SSL::Host.ca_location = :local
 
       ca = Puppet::SSL::CertificateAuthority.new
       ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.indirection.find(Puppet[:certname])
     end
 
     after do
-      @tmpfile.delete
       Puppet.settings.clear
 
-      system("rm -rf #{@dir}")
-
       Puppet::SSL::Host.ca_location = :none
     end
 
     describe "before listening" do
       it "should not be reachable at the specified address and port" do
         lambda { TCPSocket.new('127.0.0.1', 34343) }.should raise_error
       end
     end
 
     describe "when listening" do
       it "should be reachable on the specified address and port" do
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.listen
         lambda { TCPSocket.new('127.0.0.1', 34343) }.should_not raise_error
       end
 
       it "should default to '0.0.0.0' as its bind address" do
         Puppet.settings.clear
         Puppet[:servertype] = 'webrick'
         Puppet[:bindaddress].should == '0.0.0.0'
       end
 
       it "should use any specified bind address" do
         Puppet[:bindaddress] = "127.0.0.1"
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.stubs(:unlisten) # we're breaking listening internally, so we have to keep it from unlistening
         @server.send(:http_server).expects(:listen).with { |args| args[:address] == "127.0.0.1" }
         @server.listen
       end
 
       it "should not allow multiple servers to listen on the same address and port" do
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.listen
         @server2 = Puppet::Network::Server.new(@params.merge(:port => 34343))
         lambda { @server2.listen }.should raise_error
       end
 
       after :each do
         @server.unlisten if @server && @server.listening?
       end
     end
 
     describe "after unlistening" do
       it "should not be reachable on the port and address assigned" do
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.listen
         @server.unlisten
         lambda { TCPSocket.new('127.0.0.1', 34343) }.should raise_error(Errno::ECONNREFUSED)
       end
     end
   end
 end
diff --git a/spec/integration/type/tidy_spec.rb b/spec/integration/type/tidy_spec.rb
index 08a24099c..d1bb62d6e 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", :fails_on_windows => true do
+  it "should be able to remove dead links", :unless => Puppet.features.microsoft_windows? 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 771e6a718..92fc6554c 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", :fails_on_windows => true do
+  it "should be able to load files directly from modules" 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 be5887f01..750f25ab8 100755
--- a/spec/unit/application/inspect_spec.rb
+++ b/spec/unit/application/inspect_spec.rb
@@ -1,283 +1,283 @@
 #!/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.close
       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", :fails_on_windows => true do
+        it "should not send unreadable files", :unless => Puppet.features.microsoft_windows? 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/face/ca_spec.rb b/spec/unit/face/ca_spec.rb
index b8c82ce99..1df4d7c53 100755
--- a/spec/unit/face/ca_spec.rb
+++ b/spec/unit/face/ca_spec.rb
@@ -1,355 +1,355 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/face'
 
-describe Puppet::Face[:ca, '0.1.0'] do
+describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   before :each do
     Puppet.run_mode.stubs(:master?).returns(true)
     Puppet[:ca]     = true
     Puppet[:ssldir] = tmpdir("face-ca-ssldir")
 
     Puppet::SSL::Host.ca_location = :only
     Puppet[:certificate_revocation] = true
 
     # This is way more intimate than I want to be with the implementation, but
     # there doesn't seem any other way to test this. --daniel 2011-07-18
     Puppet::SSL::CertificateAuthority.stubs(:instance).returns(
         # ...and this actually does the directory creation, etc.
         Puppet::SSL::CertificateAuthority.new
     )
   end
 
   def make_certs(csr_names, crt_names)
     Array(csr_names).map do |name|
       Puppet::SSL::Host.new(name).generate_certificate_request
     end
 
     Array(crt_names).map do |name|
       Puppet::SSL::Host.new(name).generate
     end
   end
 
   context "#verify" do
     let :action do Puppet::Face[:ca, '0.1.0'].get_action(:verify) end
 
     it "should not explode if there is no certificate" do
       expect {
         subject.verify('random-host').should == {
           :host => 'random-host', :valid => false,
           :error => 'Could not find a certificate for random-host'
         }
       }.should_not raise_error
     end
 
     it "should not explode if there is only a CSR" do
       make_certs('random-host', [])
       expect {
         subject.verify('random-host').should == {
           :host => 'random-host', :valid => false,
           :error => 'Could not find a certificate for random-host'
         }
       }.should_not raise_error
     end
 
     it "should verify a signed certificate" do
       make_certs([], 'random-host')
       subject.verify('random-host').should == {
         :host => 'random-host', :valid => true
       }
     end
 
     it "should not verify a revoked certificate" do
       make_certs([], 'random-host')
       subject.revoke('random-host')
 
       expect {
         subject.verify('random-host').should == {
           :host => 'random-host', :valid => false,
           :error => 'certificate revoked'
         }
       }.should_not raise_error
     end
 
     it "should verify a revoked certificate if CRL use was turned off" do
       make_certs([], 'random-host')
       subject.revoke('random-host')
 
       Puppet[:certificate_revocation] = false
       subject.verify('random-host').should == {
         :host => 'random-host', :valid => true
       }
     end
   end
 
   context "#fingerprint" do
     let :action do Puppet::Face[:ca, '0.1.0'].get_action(:fingerprint) end
 
     it "should have a 'digest' option" do
       action.should be_option :digest
     end
 
     it "should not explode if there is no certificate" do
       expect {
         subject.fingerprint('random-host').should be_nil
       }.should_not raise_error
     end
 
     it "should fingerprint a CSR" do
       make_certs('random-host', [])
       expect {
         subject.fingerprint('random-host').should =~ /^[0-9A-F:]+$/
       }.should_not raise_error
     end
 
     it "should fingerprint a certificate" do
       make_certs([], 'random-host')
       subject.fingerprint('random-host').should =~ /^[0-9A-F:]+$/
     end
 
     %w{md5 MD5 sha1 ShA1 SHA1 RIPEMD160 sha256 sha512}.each do |digest|
       it "should fingerprint with #{digest.inspect}" do
         make_certs([], 'random-host')
         subject.fingerprint('random-host', :digest => digest).should =~ /^[0-9A-F:]+$/
       end
 
       it "should fingerprint with #{digest.to_sym} as a symbol" do
         make_certs([], 'random-host')
         subject.fingerprint('random-host', :digest => digest.to_sym).
           should =~ /^[0-9A-F:]+$/
       end
     end
   end
 
   context "#print" do
     let :action do Puppet::Face[:ca, '0.1.0'].get_action(:print) end
 
     it "should not explode if there is no certificate" do
       expect {
         subject.print('random-host').should be_nil
       }.should_not raise_error
     end
 
     it "should return nothing if there is only a CSR" do
       make_certs('random-host', [])
       expect {
         subject.print('random-host').should be_nil
       }.should_not raise_error
     end
 
     it "should return the certificate content if there is a cert" do
       make_certs([], 'random-host')
       text = subject.print('random-host')
       text.should be_an_instance_of String
       text.should =~ /^Certificate:/
       text.should =~ /Issuer: CN=Puppet CA: /
       text.should =~ /Subject: CN=random-host$/
     end
   end
 
   context "#sign" do
     let :action do Puppet::Face[:ca, '0.1.0'].get_action(:sign) end
 
     it "should not explode if there is no CSR" do
       expect {
         subject.sign('random-host').
           should == 'Could not find certificate request for random-host'
       }.should_not raise_error
     end
 
     it "should not explode if there is a signed cert" do
       make_certs([], 'random-host')
       expect {
         subject.sign('random-host').
           should == 'Could not find certificate request for random-host'
       }.should_not raise_error
     end
 
     it "should sign a CSR if one exists" do
       make_certs('random-host', [])
       subject.sign('random-host').should be_an_instance_of Puppet::SSL::Certificate
 
       list = subject.list(:signed => true)
       list.length.should == 1
       list.first.name.should == 'random-host'
     end
   end
 
   context "#generate" do
     let :action do Puppet::Face[:ca, '0.1.0'].get_action(:generate) end
 
     it "should generate a certificate if requested" do
       subject.list(:all => true).should == []
 
       subject.generate('random-host')
 
       list = subject.list(:signed => true)
       list.length.should == 1
       list.first.name.should == 'random-host'
     end
 
     it "should not explode if a CSR with that name already exists" do
       make_certs('random-host', [])
       expect {
         subject.generate('random-host').should =~ /already has a certificate request/
       }.should_not raise_error
     end
 
     it "should not explode if the certificate with that name already exists" do
       make_certs([], 'random-host')
       expect {
         subject.generate('random-host').should =~ /already has a certificate/
       }.should_not raise_error
     end
   end
 
   context "#revoke" do
     let :action do Puppet::Face[:ca, '0.1.0'].get_action(:revoke) end
 
     it "should not explode when asked to revoke something that doesn't exist" do
       expect { subject.revoke('nonesuch') }.should_not raise_error
     end
 
     it "should let the user know what went wrong" do
       subject.revoke('nonesuch').should == 'Nothing was revoked'
     end
 
     it "should revoke a certificate" do
       make_certs([], 'random-host')
       found = subject.list(:all => true, :subject => 'random-host')
       subject.get_action(:list).when_rendering(:console).call(found).
         should =~ /^\+ random-host/
 
       subject.revoke('random-host')
 
       found = subject.list(:all => true, :subject => 'random-host')
       subject.get_action(:list).when_rendering(:console).call(found).
         should =~ /^- random-host  \([:0-9A-F]+\) \(certificate revoked\)/
     end
   end
 
   context "#destroy" do
     let :action do Puppet::Face[:ca, '0.1.0'].get_action(:destroy) end
 
     it "should not explode when asked to delete something that doesn't exist" do
       expect { subject.destroy('nonesuch') }.should_not raise_error
     end
 
     it "should let the user know if nothing was deleted" do
       subject.destroy('nonesuch').should == "Nothing was deleted"
     end
 
     it "should destroy a CSR, if we have one" do
       make_certs('random-host', [])
       subject.list(:pending => true, :subject => 'random-host').should_not == []
 
       subject.destroy('random-host')
 
       subject.list(:pending => true, :subject => 'random-host').should == []
     end
 
     it "should destroy a certificate, if we have one" do
       make_certs([], 'random-host')
       subject.list(:signed => true, :subject => 'random-host').should_not == []
 
       subject.destroy('random-host')
 
       subject.list(:signed => true, :subject => 'random-host').should == []
     end
 
     it "should tell the user something was deleted" do
       make_certs([], 'random-host')
       subject.list(:signed => true, :subject => 'random-host').should_not == []
       subject.destroy('random-host').
         should == "Deleted for random-host: Puppet::SSL::Certificate, Puppet::SSL::Key"
     end
   end
 
   context "#list" do
     let :action do Puppet::Face[:ca, '0.1.0'].get_action(:list) end
 
     context "options" do
       subject { Puppet::Face[:ca, '0.1.0'].get_action(:list) }
       it { should be_option :pending }
       it { should be_option :signed  }
       it { should be_option :all     }
       it { should be_option :subject }
     end
 
     context "with no hosts in CA" do
       [:pending, :signed, :all].each do |type|
         it "should return nothing for #{type}" do
           subject.list(type => true).should == []
         end
 
         it "should not fail when a matcher is passed" do
           expect {
             subject.list(type => true, :subject => '.').should == []
           }.should_not raise_error
         end
       end
     end
 
     context "with some hosts" do
       csr_names = (1..3).map {|n| "csr-#{n}" }
       crt_names = (1..3).map {|n| "crt-#{n}" }
       all_names = csr_names + crt_names
 
       {
         {}                                    => csr_names,
         { :pending => true                  } => csr_names,
 
         { :signed  => true                  } => crt_names,
 
         { :all     => true                  } => all_names,
         { :pending => true, :signed => true } => all_names,
       }.each do |input, expect|
         it "should map #{input.inspect} to #{expect.inspect}" do
           make_certs(csr_names, crt_names)
           subject.list(input).map(&:name).should =~ expect
         end
 
         ['', '.', '2', 'none'].each do |pattern|
           filtered = expect.select {|x| Regexp.new(pattern).match(x) }
 
           it "should filter all hosts matching #{pattern.inspect} to #{filtered.inspect}" do
             make_certs(csr_names, crt_names)
             subject.list(input.merge :subject => pattern).map(&:name).should =~ filtered
           end
         end
       end
 
       context "when_rendering :console" do
         { [["csr1.local"], []] => '^  csr1.local ',
           [[], ["crt1.local"]] => '^\+ crt1.local ',
           [["csr2"], ["crt2"]] => ['^  csr2 ', '^\+ crt2 ']
         }.each do |input, pattern|
           it "should render #{input.inspect} to match #{pattern.inspect}" do
             make_certs(*input)
             text = action.when_rendering(:console).call(subject.list(:all => true))
             Array(pattern).each do |item|
               text.should =~ Regexp.new(item)
             end
           end
         end
       end
     end
   end
 
   actions = %w{destroy list revoke generate sign print verify fingerprint}
   actions.each do |action|
     it { should be_action action }
     it "should fail #{action} when not a CA" do
       Puppet[:ca] = false
       expect {
         case subject.method(action).arity
         when -1 then subject.send(action)
         when -2 then subject.send(action, 'dummy')
         else
           raise "#{action} has arity #{subject.method(action).arity}"
         end
       }.should raise_error(/Not a CA/)
     end
   end
 end
diff --git a/spec/unit/network/handler/fileserver_spec.rb b/spec/unit/network/handler/fileserver_spec.rb
index 851736e76..2b8094b8b 100755
--- a/spec/unit/network/handler/fileserver_spec.rb
+++ b/spec/unit/network/handler/fileserver_spec.rb
@@ -1,201 +1,201 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/network/handler/fileserver'
 
 describe Puppet::Network::Handler::FileServer do
   include PuppetSpec::Files
 
   def create_file(filename)
     File.open(filename, "w") { |f| f.puts filename}
   end
 
   def create_nested_file
     dirname = File.join(@basedir, "nested_dir")
     Dir.mkdir(dirname)
     file = File.join(dirname, "nested_dir_file")
     create_file(file)
   end
 
   before do
     @basedir = tmpdir("test_network_handler")
     @file = File.join(@basedir, "aFile")
     @link = File.join(@basedir, "aLink")
     create_file(@file)
     @mount = Puppet::Network::Handler::FileServer::Mount.new("some_path", @basedir)
   end
 
   describe "when parsing the fileserver.conf" do
     it "should create a valid mount when a valid conf is read" do
       config_file = tmpfile('fileserver.conf')
       mountdir = tmpdir('mountdir')
 
       conf_text = <<-HEREDOC
         [mymount]
           path #{mountdir}
           allow anyone.com
           deny nobody.com
       HEREDOC
       File.open(config_file, 'w') { |f| f.write conf_text }
 
       fs = Puppet::Network::Handler::FileServer.new(:Config => config_file) 
       mounts = fs.instance_variable_get(:@mounts)
       mount = mounts["mymount"]
       mount.path == mountdir
       mount.instance_variable_get(:@declarations).map {|d| d.pattern}.should =~ [["com", "nobody"], ["com", "anyone"]]
     end
 
     ['path', 'allow', 'deny'].each do |arg|
       it "should error if config file doesn't specify a mount for #{arg} argument" do
         config_file = tmpfile('fileserver.conf')
         File.open(config_file, 'w') { |f| f.puts "#{arg} 127.0.0.1/24" }
 
         expect { 
           Puppet::Network::Handler::FileServer.new(:Config => config_file) 
         }.should raise_error(Puppet::Network::Handler::FileServerError, "No mount specified for argument #{arg} 127.0.0.1/24")
       end
     end
   end
 
   it "should list a single directory" do
     @mount.list("/", false, false).should == [["/", "directory"]]
   end
 
   it "should list a file within a directory when given the file path" do
     @mount.list("/aFile", false, "false").should == [["/", "file"]]
   end
 
   it "should list a file within a directory when given the file path with recursion" do
     @mount.list("/aFile", true, "false").should == [["/", "file"]]
   end
 
   it "should return nil for a non-existent path" do
     @mount.list("/no_such_file", false, false).should be(nil)
   end
 
-  it "should list a symbolic link as a file when given the link path" do
+  it "should list a symbolic link as a file when given the link path", :unless => Puppet.features.microsoft_windows? do
     File.symlink(@file, @link)
     @mount.list("/aLink", false, false).should == [["/", "file"]]
   end
 
-  it "should return nil for a dangling symbolic link when given the link path" do
+  it "should return nil for a dangling symbolic link when given the link path", :unless => Puppet.features.microsoft_windows? do
     File.symlink("/some/where", @link)
     @mount.list("/aLink", false, false).should be(nil)
   end
 
   it "should list directory contents of a flat directory structure when asked to recurse" do
     list = @mount.list("/", true, false)
     list.should include(["/aFile", "file"])
     list.should include(["/", "directory"])
     list.should have(2).items
   end
 
   it "should list the contents of a nested directory" do
     create_nested_file
     list = @mount.list("/", true, false)
     list.sort.should == [   ["/aFile", "file"], ["/", "directory"] , ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
   end
 
   it "should list the contents of a directory ignoring files that match" do
     create_nested_file
     list = @mount.list("/", true, "*File")
     list.sort.should == [   ["/", "directory"] , ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
   end
 
   it "should list the contents of a directory ignoring directories that match" do
     create_nested_file
     list = @mount.list("/", true, "*nested_dir")
     list.sort.should == [   ["/aFile", "file"], ["/", "directory"] ].sort
   end
 
   it "should list the contents of a directory ignoring all ignore patterns that match" do
     create_nested_file
     list = @mount.list("/", true, ["*File" , "*nested_dir"])
     list.should == [ ["/", "directory"] ]
   end
 
   it "should list the directory when recursing to a depth of zero" do
     create_nested_file
     list = @mount.list("/", 0, false)
     list.should == [["/", "directory"]]
   end
 
   it "should list the base directory and files and nested directory to a depth of one" do
     create_nested_file
     list = @mount.list("/", 1, false)
     list.sort.should == [ ["/aFile", "file"], ["/nested_dir", "directory"], ["/", "directory"] ].sort
   end
 
   it "should list the base directory and files and nested directory to a depth of two" do
     create_nested_file
     list = @mount.list("/", 2, false)
     list.sort.should == [   ["/aFile", "file"], ["/", "directory"] , ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
   end
 
   it "should list the base directory and files and nested directory to a depth greater than the directory structure" do
     create_nested_file
     list = @mount.list("/", 42, false)
     list.sort.should == [   ["/aFile", "file"], ["/", "directory"] , ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
   end
 
-  it "should list a valid symbolic link as a file when recursing base dir" do
+  it "should list a valid symbolic link as a file when recursing base dir", :unless => Puppet.features.microsoft_windows? do
     File.symlink(@file, @link)
     list = @mount.list("/", true, false)
     list.sort.should == [ ["/", "directory"], ["/aFile", "file"], ["/aLink", "file"] ].sort
   end
 
-  it "should not error when a dangling symlink is present" do
+  it "should not error when a dangling symlink is present", :unless => Puppet.features.microsoft_windows? do
     File.symlink("/some/where", @link)
     lambda { @mount.list("/", true, false) }.should_not raise_error
   end
 
-  it "should return the directory contents of valid entries when a dangling symlink is present" do
+  it "should return the directory contents of valid entries when a dangling symlink is present", :unless => Puppet.features.microsoft_windows? do
     File.symlink("/some/where", @link)
     list = @mount.list("/", true, false)
     list.sort.should == [ ["/aFile", "file"], ["/", "directory"] ].sort
   end
 
   describe Puppet::Network::Handler::FileServer::PluginMount, :'fails_on_ruby_1.9.2' => true do
     PLUGINS = Puppet::Network::Handler::FileServer::PLUGINS
 
     # create a module plugin hierarchy
     def create_plugin(mod, plugin)
       dirname = File.join(@basedir, mod)
       Dir.mkdir(dirname)
       plugins = File.join(dirname, PLUGINS)
       Dir.mkdir(plugins)
       facter = File.join(plugins, plugin)
       Dir.mkdir(facter)
       create_file(File.join(facter,"fact.rb"))
     end
 
     before :each do
       @modules = ["one","two"]
       @modules.each { |m| create_plugin(m, "facter") }
 
       Puppet::Node::Environment.new.stubs(:modulepath).returns @basedir
 
       @mount = Puppet::Network::Handler::FileServer::PluginMount.new(PLUGINS)
       @mount.allow("*")
     end
 
     it "should list a file within a directory when given the file path with recursion" do
       @mount.list("facter/fact.rb", true, "false").should == [["/", "file"], ["/", "file"]]
     end
 
     it "should return a merged view of all plugins for all modules" do
       list = @mount.list("facter",true,false)
       list.should == [["/", "directory"], ["/fact.rb", "file"], ["/", "directory"], ["/fact.rb", "file"]]
     end
 
     it "should not fail for inexistant plugins type" do
       @mount.list("puppet/parser",true,false)
     end
 
   end
 
   after do
     FileUtils.rm_rf(@basedir)
   end
 
 end
diff --git a/spec/unit/network/http/webrick_spec.rb b/spec/unit/network/http/webrick_spec.rb
index 72660efda..f84e78e24 100755
--- a/spec/unit/network/http/webrick_spec.rb
+++ b/spec/unit/network/http/webrick_spec.rb
@@ -1,336 +1,336 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/network/handler'
 require 'puppet/network/http'
 require 'puppet/network/http/webrick'
 
-describe Puppet::Network::HTTP::WEBrick, "after initializing" do
+describe Puppet::Network::HTTP::WEBrick, "after initializing", :unless => Puppet.features.microsoft_windows? do
   it "should not be listening" do
     Puppet::Network::HTTP::WEBrick.new.should_not be_listening
   end
 end
 
-describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do
+describe Puppet::Network::HTTP::WEBrick, "when turning on listening", :unless => Puppet.features.microsoft_windows? do
   before do
     @mock_webrick = stub('webrick', :[] => {}, :listeners => [], :status => :Running)
     [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
     WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
     @server = Puppet::Network::HTTP::WEBrick.new
     [:setup_logger, :setup_ssl].each {|meth| @server.stubs(meth).returns({})} # the empty hash is required because of how we're merging
     @listen_params = { :address => "127.0.0.1", :port => 31337, :xmlrpc_handlers => [], :protocols => [ :rest ] }
   end
 
   it "should fail if already listening" do
     @server.listen(@listen_params)
     Proc.new { @server.listen(@listen_params) }.should raise_error(RuntimeError)
   end
 
   it "should require at least one protocol" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :protocols == k}) }.should raise_error(ArgumentError)
   end
 
   it "should require a listening address to be specified" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :address == k})}.should raise_error(ArgumentError)
   end
 
   it "should require a listening port to be specified" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :port == k})}.should raise_error(ArgumentError)
   end
 
   it "should order a webrick server to start in a separate thread" do
     @mock_webrick.expects(:start)
     # If you remove this you'll sometimes get race condition problems
     Thread.expects(:new).yields
     @server.listen(@listen_params)
   end
 
   it "should tell webrick to listen on the specified address and port" do
     WEBrick::HTTPServer.expects(:new).with {|args|
       args[:Port] == 31337 and args[:BindAddress] == "127.0.0.1"
     }.returns(@mock_webrick)
     @server.listen(@listen_params)
   end
 
   it "should configure a logger for webrick" do
     @server.expects(:setup_logger).returns(:Logger => :mylogger)
 
     WEBrick::HTTPServer.expects(:new).with {|args|
       args[:Logger] == :mylogger
     }.returns(@mock_webrick)
 
     @server.listen(@listen_params)
   end
 
   it "should configure SSL for webrick" do
     @server.expects(:setup_ssl).returns(:Ssl => :testing, :Other => :yay)
 
     WEBrick::HTTPServer.expects(:new).with {|args|
       args[:Ssl] == :testing and args[:Other] == :yay
     }.returns(@mock_webrick)
 
     @server.listen(@listen_params)
   end
 
   it "should be listening" do
     @server.listen(@listen_params)
     @server.should be_listening
   end
 
   describe "when the REST protocol is requested" do
     it "should register the REST handler at /" do
       # We don't care about the options here.
       @mock_webrick.expects(:mount).with { |path, klass, options| path == "/" and klass == Puppet::Network::HTTP::WEBrickREST }
 
       @server.listen(@listen_params.merge(:protocols => [:rest]))
     end
   end
 
   describe "when the XMLRPC protocol is requested" do
     before do
       @servlet = mock 'servlet'
 
       Puppet::Network::XMLRPC::WEBrickServlet.stubs(:new).returns @servlet
 
       @master_handler = mock('master_handler')
       @file_handler = mock('file_handler')
 
       @master = mock 'master'
       @file = mock 'file'
       @master_handler.stubs(:new).returns @master
       @file_handler.stubs(:new).returns @file
 
       Puppet::Network::Handler.stubs(:handler).with(:master).returns @master_handler
       Puppet::Network::Handler.stubs(:handler).with(:fileserver).returns @file_handler
     end
 
     it "should do nothing if no xmlrpc handlers have been specified" do
       Puppet::Network::Handler.expects(:handler).never
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => []))
     end
 
     it "should look the handler classes up via their base class" do
       Puppet::Network::Handler.expects(:handler).with(:master).returns @master_handler
       Puppet::Network::Handler.expects(:handler).with(:fileserver).returns @file_handler
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
     end
 
     it "should create an instance for each requested xmlrpc handler" do
       @master_handler.expects(:new).returns @master
       @file_handler.expects(:new).returns @file
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
     end
 
     it "should create a webrick servlet with the xmlrpc handler instances" do
       Puppet::Network::XMLRPC::WEBrickServlet.expects(:new).with([@master, @file]).returns @servlet
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
     end
 
     it "should mount the webrick servlet at /RPC2" do
       @mock_webrick.stubs(:mount)
       @mock_webrick.expects(:mount).with("/RPC2", @servlet)
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
     end
   end
 end
 
 
-describe Puppet::Network::HTTP::WEBrick, "when looking up the class to handle a protocol" do
+describe Puppet::Network::HTTP::WEBrick, "when looking up the class to handle a protocol", :unless => Puppet.features.microsoft_windows? do
   it "should require a protocol" do
     lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol }.should raise_error(ArgumentError)
   end
 
   it "should accept a protocol" do
     lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol("bob") }.should_not raise_error(ArgumentError)
   end
 
   it "should use a WEBrick + REST class when a REST protocol is specified" do
     Puppet::Network::HTTP::WEBrick.class_for_protocol("rest").should == Puppet::Network::HTTP::WEBrickREST
   end
 
   it "should fail when an unknown protocol is specified" do
     lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol("abcdefg") }.should raise_error
   end
 end
 
-describe Puppet::Network::HTTP::WEBrick, "when turning off listening" do
+describe Puppet::Network::HTTP::WEBrick, "when turning off listening", :unless => Puppet.features.microsoft_windows? do
   before do
     @mock_webrick = stub('webrick', :[] => {}, :listeners => [], :status => :Running)
     [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
     WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
     @server = Puppet::Network::HTTP::WEBrick.new
     [:setup_logger, :setup_ssl].each {|meth| @server.stubs(meth).returns({})} # the empty hash is required because of how we're merging
     @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
   end
 
   it "should fail unless listening" do
     Proc.new { @server.unlisten }.should raise_error(RuntimeError)
   end
 
   it "should order webrick server to stop" do
     @mock_webrick.expects(:shutdown)
     @server.listen(@listen_params)
     @server.unlisten
   end
 
   it "should no longer be listening" do
     @server.listen(@listen_params)
     @server.unlisten
     @server.should_not be_listening
   end
 end
 
-describe Puppet::Network::HTTP::WEBrick do
+describe Puppet::Network::HTTP::WEBrick, :unless => Puppet.features.microsoft_windows? do
   before do
     @mock_webrick = stub('webrick', :[] => {})
     [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
     WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
     @server = Puppet::Network::HTTP::WEBrick.new
   end
 
   describe "when configuring an http logger" do
     before do
       Puppet.settings.stubs(:value).returns "something"
       Puppet.settings.stubs(:use)
       @filehandle = stub 'handle', :fcntl => nil, :sync => nil
 
       File.stubs(:open).returns @filehandle
     end
 
     it "should use the settings for :main, :ssl, and the process name" do
       Puppet.settings.stubs(:value).with(:name).returns "myname"
       Puppet.settings.expects(:use).with(:main, :ssl, "myname")
 
       @server.setup_logger
     end
 
     it "should use the masterlog if the run_mode is master" do
       Puppet.run_mode.stubs(:master?).returns(true)
       Puppet.settings.expects(:value).with(:masterhttplog).returns "/master/log"
 
       File.expects(:open).with("/master/log", "a+").returns @filehandle
 
       @server.setup_logger
     end
 
     it "should use the httplog if the run_mode is not master" do
       Puppet.run_mode.stubs(:master?).returns(false)
       Puppet.settings.expects(:value).with(:httplog).returns "/other/log"
 
       File.expects(:open).with("/other/log", "a+").returns @filehandle
 
       @server.setup_logger
     end
 
     describe "and creating the logging filehandle" do
       it "should set fcntl to 'Fcntl::F_SETFD, Fcntl::FD_CLOEXEC'" do
         @filehandle.expects(:fcntl).with(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
         @server.setup_logger
       end
 
       it "should sync the filehandle" do
         @filehandle.expects(:sync)
 
         @server.setup_logger
       end
     end
 
     it "should create a new WEBrick::Log instance with the open filehandle" do
       WEBrick::Log.expects(:new).with(@filehandle)
 
       @server.setup_logger
     end
 
     it "should set debugging if the current loglevel is :debug" do
       Puppet::Util::Log.expects(:level).returns :debug
 
       WEBrick::Log.expects(:new).with { |handle, debug| debug == WEBrick::Log::DEBUG }
 
       @server.setup_logger
     end
 
     it "should return the logger as the main log" do
       logger = mock 'logger'
       WEBrick::Log.expects(:new).returns logger
 
       @server.setup_logger[:Logger].should == logger
     end
 
     it "should return the logger as the access log using both the Common and Referer log format" do
       logger = mock 'logger'
       WEBrick::Log.expects(:new).returns logger
 
       @server.setup_logger[:AccessLog].should == [
         [logger, WEBrick::AccessLog::COMMON_LOG_FORMAT],
         [logger, WEBrick::AccessLog::REFERER_LOG_FORMAT]
       ]
     end
   end
 
   describe "when configuring ssl" do
     before do
       @key = stub 'key', :content => "mykey"
       @cert = stub 'cert', :content => "mycert"
       @host = stub 'host', :key => @key, :certificate => @cert, :name => "yay", :ssl_store => "mystore"
 
       Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns @cert
 
       Puppet::SSL::Host.stubs(:localhost).returns @host
     end
 
     it "should use the key from the localhost SSL::Host instance" do
       Puppet::SSL::Host.expects(:localhost).returns @host
       @host.expects(:key).returns @key
 
       @server.setup_ssl[:SSLPrivateKey].should == "mykey"
     end
 
     it "should configure the certificate" do
       @server.setup_ssl[:SSLCertificate].should == "mycert"
     end
 
     it "should fail if no CA certificate can be found" do
       Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns nil
 
       lambda { @server.setup_ssl }.should raise_error(Puppet::Error)
     end
 
     it "should specify the path to the CA certificate" do
       Puppet.settings.stubs(:value).returns "whatever"
       Puppet.settings.stubs(:value).with(:hostcrl).returns 'false'
       Puppet.settings.stubs(:value).with(:localcacert).returns '/ca/crt'
 
       @server.setup_ssl[:SSLCACertificateFile].should == "/ca/crt"
     end
 
     it "should start ssl immediately" do
       @server.setup_ssl[:SSLStartImmediately].should be_true
     end
 
     it "should enable ssl" do
       @server.setup_ssl[:SSLEnable].should be_true
     end
 
     it "should configure the verification method as 'OpenSSL::SSL::VERIFY_PEER'" do
       @server.setup_ssl[:SSLVerifyClient].should == OpenSSL::SSL::VERIFY_PEER
     end
 
     it "should add an x509 store" do
       Puppet.settings.stubs(:value).returns "whatever"
       Puppet.settings.stubs(:value).with(:hostcrl).returns '/my/crl'
 
       @host.expects(:ssl_store).returns "mystore"
 
       @server.setup_ssl[:SSLCertificateStore].should == "mystore"
     end
 
     it "should set the certificate name to 'nil'" do
       @server.setup_ssl[:SSLCertName].should be_nil
     end
   end
 end
diff --git a/spec/unit/resource/catalog_spec.rb b/spec/unit/resource/catalog_spec.rb
index a5743afa3..6a9b1196f 100755
--- a/spec/unit/resource/catalog_spec.rb
+++ b/spec/unit/resource/catalog_spec.rb
@@ -1,1085 +1,1086 @@
 #!/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 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", :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")
+        path = make_absolute("/tmp/foo")
+        @resource = Puppet::Type.type(:file).new(:title => path)
+        @other    = Puppet::Type.type(:file).new(:title => "another file", :path => path)
 
         @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/)
+        expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias File\[another file\] to \["#{Regexp.escape(path)}"\].*resource \["File", "#{Regexp.escape(path)}"\] 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
 
     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
     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
       @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/inventory_spec.rb b/spec/unit/ssl/inventory_spec.rb
index 3d141d0cd..000f0a253 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
+describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? 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", :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/type/cron_spec.rb b/spec/unit/type/cron_spec.rb
index 7bf92eb02..f2c18896b 100755
--- a/spec/unit/type/cron_spec.rb
+++ b/spec/unit/type/cron_spec.rb
@@ -1,490 +1,490 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type.type(:cron) do
+describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows? do
   before do
     @class = Puppet::Type.type(:cron)
 
     # Init a fake provider
     @provider_class = stub 'provider_class', :ancestors => [], :name => 'fake', :suitable? => true, :supports_parameter? => true
     @class.stubs(:defaultprovider).returns @provider_class
     @class.stubs(:provider).returns @provider_class
 
     @provider = stub 'provider', :class => @provider_class, :clean => nil
     @provider.stubs(:is_a?).returns false
     @provider_class.stubs(:new).returns @provider
 
     @cron = @class.new( :name => "foo" )
   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
 
     [:command, :special, :minute, :hour, :weekday, :month, :monthday, :environment, :user, :target].each do |property|
       it "should have a #{property} property" do
         @class.attrtype(property).should == :property
       end
     end
 
     [:command, :minute, :hour, :weekday, :month, :monthday].each do |cronparam|
       it "should have #{cronparam} of type CronParam" do
         @class.attrclass(cronparam).ancestors.should include CronParam
       end
     end
 
   end
 
 
   describe "when validating attribute" do
 
     describe "ensure" 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 => :present) }.should_not raise_error
       end
     end
 
     describe "minute" do
 
       it "should support absent" do
         proc { @class.new(:name => 'foo', :minute => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { @class.new(:name => 'foo', :minute => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         @class.new(:name => 'foo', :minute => 'absent')[:minute].should == :absent
       end
 
       it "should translate * to :absent" do
         @class.new(:name => 'foo', :minute => '*')[:minute].should == :absent
       end
 
       it "should support valid single values" do
         proc { @class.new(:name => 'foo', :minute => '0') }.should_not raise_error
         proc { @class.new(:name => 'foo', :minute => '1') }.should_not raise_error
         proc { @class.new(:name => 'foo', :minute => '59') }.should_not raise_error
       end
 
       it "should not support non numeric characters" do
         proc { @class.new(:name => 'foo', :minute => 'z59') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :minute => '5z9') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :minute => '59z') }.should raise_error(Puppet::Error)
       end
 
       it "should not support single values out of range" do
 
         proc { @class.new(:name => 'foo', :minute => '-1') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :minute => '60') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :minute => '61') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :minute => '120') }.should raise_error(Puppet::Error)
       end
 
       it "should support valid multiple values" do
         proc { @class.new(:name => 'foo', :minute => ['0','1','59'] ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :minute => ['40','30','20'] ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :minute => ['10','30','20'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { @class.new(:name => 'foo', :minute => ['0','1','60'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :minute => ['0','120','59'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.should raise_error(Puppet::Error)
         # two invalid
         proc { @class.new(:name => 'foo', :minute => ['0','61','62'] ) }.should raise_error(Puppet::Error)
         # all invalid
         proc { @class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.should raise_error(Puppet::Error)
       end
 
       it "should support valid step syntax" do
         proc { @class.new(:name => 'foo', :minute => '*/2' ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :minute => '10-16/2' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { @class.new(:name => 'foo', :minute => '*/A' ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :minute => '*/2A' ) }.should raise_error(Puppet::Error)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { @class.new(:name => 'foo', :minute => '*/120' ) }.should raise_error(Puppet::Error)
       end
 
     end
 
     describe "hour" do
 
      it "should support absent" do
         proc { @class.new(:name => 'foo', :hour => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { @class.new(:name => 'foo', :hour => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         @class.new(:name => 'foo', :hour => 'absent')[:hour].should == :absent
       end
 
       it "should translate * to :absent" do
         @class.new(:name => 'foo', :hour => '*')[:hour].should == :absent
       end
 
       it "should support valid single values" do
         proc { @class.new(:name => 'foo', :hour => '0') }.should_not raise_error
         proc { @class.new(:name => 'foo', :hour => '11') }.should_not raise_error
         proc { @class.new(:name => 'foo', :hour => '12') }.should_not raise_error
         proc { @class.new(:name => 'foo', :hour => '13') }.should_not raise_error
         proc { @class.new(:name => 'foo', :hour => '23') }.should_not raise_error
       end
 
       it "should not support non numeric characters" do
         proc { @class.new(:name => 'foo', :hour => 'z15') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :hour => '1z5') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :hour => '15z') }.should raise_error(Puppet::Error)
       end
 
       it "should not support single values out of range" do
         proc { @class.new(:name => 'foo', :hour => '-1') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :hour => '24') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :hour => '120') }.should raise_error(Puppet::Error)
       end
 
       it "should support valid multiple values" do
         proc { @class.new(:name => 'foo', :hour => ['0','1','23'] ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :hour => ['5','16','14'] ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :hour => ['16','13','9'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { @class.new(:name => 'foo', :hour => ['0','1','24'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.should raise_error(Puppet::Error)
         # two invalid
         proc { @class.new(:name => 'foo', :hour => ['0','25','26'] ) }.should raise_error(Puppet::Error)
         # all invalid
         proc { @class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.should raise_error(Puppet::Error)
       end
 
       it "should support valid step syntax" do
         proc { @class.new(:name => 'foo', :hour => '*/2' ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :hour => '10-18/4' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { @class.new(:name => 'foo', :hour => '*/A' ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :hour => '*/2A' ) }.should raise_error(Puppet::Error)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { @class.new(:name => 'foo', :hour => '*/26' ) }.should raise_error(Puppet::Error)
       end
 
     end
 
    describe "weekday" do
 
       it "should support absent" do
         proc { @class.new(:name => 'foo', :weekday => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { @class.new(:name => 'foo', :weekday => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         @class.new(:name => 'foo', :weekday => 'absent')[:weekday].should == :absent
       end
 
       it "should translate * to :absent" do
         @class.new(:name => 'foo', :weekday => '*')[:weekday].should == :absent
       end
 
       it "should support valid numeric weekdays" do
         proc { @class.new(:name => 'foo', :weekday => '0') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => '1') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => '6') }.should_not raise_error
         # According to http://www.manpagez.com/man/5/crontab 7 is also valid (Sunday)
         proc { @class.new(:name => 'foo', :weekday => '7') }.should_not raise_error
       end
 
       it "should support valid weekdays as words (3 character version)" do
         proc { @class.new(:name => 'foo', :weekday => 'Monday') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Tuesday') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Wednesday') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Thursday') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Friday') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Saturday') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Sunday') }.should_not raise_error
       end
 
       it "should support valid weekdays as words (3 character version)" do
         proc { @class.new(:name => 'foo', :weekday => 'Mon') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Tue') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Wed') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Thu') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Fri') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Sat') }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => 'Sun') }.should_not raise_error
       end
 
       it "should not support numeric values out of range" do
         proc { @class.new(:name => 'foo', :weekday => '-1') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :weekday => '8') }.should raise_error(Puppet::Error)
       end
 
       it "should not support invalid weekday names" do
         proc { @class.new(:name => 'foo', :weekday => 'Sar') }.should raise_error(Puppet::Error)
       end
 
       it "should support valid multiple values" do
         proc { @class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { @class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.should raise_error(Puppet::Error)
         # two invalid
         proc { @class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.should raise_error(Puppet::Error)
         # all invalid
         proc { @class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.should raise_error(Puppet::Error)
       end
 
       it "should support valid step syntax" do
         proc { @class.new(:name => 'foo', :weekday => '*/2' ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :weekday => '0-4/2' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { @class.new(:name => 'foo', :weekday => '*/A' ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :weekday => '*/2A' ) }.should raise_error(Puppet::Error)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { @class.new(:name => 'foo', :weekday => '*/9' ) }.should raise_error(Puppet::Error)
       end
 
     end
 
     describe "month" do
 
       it "should support absent" do
         proc { @class.new(:name => 'foo', :month => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { @class.new(:name => 'foo', :month => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         @class.new(:name => 'foo', :month => 'absent')[:month].should == :absent
       end
 
       it "should translate * to :absent" do
         @class.new(:name => 'foo', :month => '*')[:month].should == :absent
       end
 
       it "should support valid numeric values" do
         proc { @class.new(:name => 'foo', :month => '1') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => '12') }.should_not raise_error
       end
 
       it "should support valid months as words" do
         proc { @class.new(:name => 'foo', :month => 'January') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'February') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'March') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'April') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'May') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'June') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'July') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'August') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'September') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'October') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'November') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'December') }.should_not raise_error
       end
 
       it "should support valid months as words (3 character short version)" do
         proc { @class.new(:name => 'foo', :month => 'Jan') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Feb') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Mar') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Apr') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'May') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Jun') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Jul') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Aug') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Sep') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Oct') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Nov') }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => 'Dec') }.should_not raise_error
       end
 
       it "should not support numeric values out of range" do
         proc { @class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => '0') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => '13') }.should raise_error(Puppet::Error)
       end
 
       it "should not support words that are not valid months" do
         proc { @class.new(:name => 'foo', :month => 'Jal') }.should raise_error(Puppet::Error)
       end
 
       it "should not support single values out of range" do
 
         proc { @class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => '60') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => '61') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => '120') }.should raise_error(Puppet::Error)
       end
 
       it "should support valid multiple values" do
         proc { @class.new(:name => 'foo', :month => ['1','9','12'] ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { @class.new(:name => 'foo', :month => ['0','1','12'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => ['1','13','10'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.should raise_error(Puppet::Error)
         # two invalid
         proc { @class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.should raise_error(Puppet::Error)
         # all invalid
         proc { @class.new(:name => 'foo', :month => ['-1','0','13'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.should raise_error(Puppet::Error)
       end
 
       it "should support valid step syntax" do
         proc { @class.new(:name => 'foo', :month => '*/2' ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :month => '1-12/3' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { @class.new(:name => 'foo', :month => '*/A' ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :month => '*/2A' ) }.should raise_error(Puppet::Error)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { @class.new(:name => 'foo', :month => '*/13' ) }.should raise_error(Puppet::Error)
       end
 
     end
 
     describe "monthday" do
 
       it "should support absent" do
         proc { @class.new(:name => 'foo', :monthday => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { @class.new(:name => 'foo', :monthday => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         @class.new(:name => 'foo', :monthday => 'absent')[:monthday].should == :absent
       end
 
       it "should translate * to :absent" do
         @class.new(:name => 'foo', :monthday => '*')[:monthday].should == :absent
       end
 
       it "should support valid single values" do
         proc { @class.new(:name => 'foo', :monthday => '1') }.should_not raise_error
         proc { @class.new(:name => 'foo', :monthday => '30') }.should_not raise_error
         proc { @class.new(:name => 'foo', :monthday => '31') }.should_not raise_error
       end
 
       it "should not support non numeric characters" do
         proc { @class.new(:name => 'foo', :monthday => 'z23') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :monthday => '2z3') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :monthday => '23z') }.should raise_error(Puppet::Error)
       end
 
       it "should not support single values out of range" do
         proc { @class.new(:name => 'foo', :monthday => '-1') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :monthday => '0') }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :monthday => '32') }.should raise_error(Puppet::Error)
       end
 
       it "should support valid multiple values" do
         proc { @class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { @class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.should raise_error(Puppet::Error)
         # two invalid
         proc { @class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.should raise_error(Puppet::Error)
         # all invalid
         proc { @class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.should raise_error(Puppet::Error)
       end
 
       it "should support valid step syntax" do
         proc { @class.new(:name => 'foo', :monthday => '*/2' ) }.should_not raise_error
         proc { @class.new(:name => 'foo', :monthday => '10-16/2' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { @class.new(:name => 'foo', :monthday => '*/A' ) }.should raise_error(Puppet::Error)
         proc { @class.new(:name => 'foo', :monthday => '*/2A' ) }.should raise_error(Puppet::Error)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { @class.new(:name => 'foo', :monthday => '*/32' ) }.should raise_error(Puppet::Error)
       end
 
     end
 
     describe "environment" do
 
       it "it should accept an :environment that looks like a path" do
         lambda do
           @cron[:environment] = 'PATH=/bin:/usr/bin:/usr/sbin'
         end.should_not raise_error
       end
 
       it "should not accept environment variables that do not contain '='" do
         lambda do
           @cron[:environment] = "INVALID"
         end.should raise_error(Puppet::Error)
       end
 
       it "should accept empty environment variables that do not contain '='" do
         lambda do
           @cron[:environment] = "MAILTO="
         end.should_not raise_error(Puppet::Error)
       end
 
       it "should accept 'absent'" do
         lambda do
           @cron[:environment] = 'absent'
         end.should_not raise_error(Puppet::Error)
       end
 
     end
 
   end
 
   it "should require a command when adding an entry" do
     entry = @class.new(:name => "test_entry", :ensure => :present)
     expect { entry.value(:command) }.should raise_error(/No command/)
   end
 
   it "should not require a command when removing an entry" do
     entry = @class.new(:name => "test_entry", :ensure => :absent)
     entry.value(:command).should == nil
   end
 end