diff --git a/spec/integration/util/settings_spec.rb b/spec/integration/util/settings_spec.rb
index b05c63107..46d783c4e 100755
--- a/spec/integration/util/settings_spec.rb
+++ b/spec/integration/util/settings_spec.rb
@@ -1,29 +1,29 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet_spec/files'
 
 describe Puppet::Util::Settings do
   include PuppetSpec::Files
 
   def minimal_default_settings
     { :noop => {:default => false, :desc => "noop"} }
   end
 
   it "should be able to make needed directories" do
     settings = Puppet::Util::Settings.new
     settings.setdefaults :main, minimal_default_settings.update( :maindir => [tmpfile("main"), "a"] )
     settings.use(:main)
 
     File.should be_directory(settings[:maindir])
   end
 
-  it "should make its directories with the corret modes" do
+  it "should make its directories with the correct modes" do
     settings = Puppet::Util::Settings.new
     settings.setdefaults :main,  minimal_default_settings.update( :maindir => {:default => tmpfile("main"), :desc => "a", :mode => 0750} )
 
     settings.use(:main)
 
-    (File.stat(settings[:maindir]).mode & 007777).should == 0750
+    (File.stat(settings[:maindir]).mode & 007777).should == (Puppet.features.microsoft_windows? ? 0755 : 0750)
   end
 end
diff --git a/spec/unit/application/inspect_spec.rb b/spec/unit/application/inspect_spec.rb
index 630470dc4..be5887f01 100755
--- a/spec/unit/application/inspect_spec.rb
+++ b/spec/unit/application/inspect_spec.rb
@@ -1,282 +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
           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/parser/functions/sprintf_spec.rb b/spec/unit/parser/functions/sprintf_spec.rb
index bd4863f23..3351c7fb3 100755
--- a/spec/unit/parser/functions/sprintf_spec.rb
+++ b/spec/unit/parser/functions/sprintf_spec.rb
@@ -1,43 +1,44 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "the sprintf function" do
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("sprintf").should == "function_sprintf"
   end
 
   it "should raise a ParseError if there is less than 1 argument" do
     lambda { @scope.function_sprintf([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should format integers" do
     result = @scope.function_sprintf(["%+05d", "23"])
     result.should(eql("+0023"))
   end
 
   it "should format floats" do
     result = @scope.function_sprintf(["%+.2f", "2.7182818284590451"])
     result.should(eql("+2.72"))
   end
 
   it "should format large floats" do
     result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
-    result.should(eql("+2.72e+16"))
+    str = Puppet.features.microsoft_windows? ? "+2.72e+016" : "+2.72e+16"
+    result.should(eql(str))
   end
 
   it "should perform more complex formatting" do
     result = @scope.function_sprintf(
       [ "<%.8s:%#5o %#8X (%-8s)>",
         "overlongstring", "23", "48879", "foo" ])
     result.should(eql("<overlong:  027   0XBEEF (foo     )>"))
   end
 
 end
diff --git a/spec/unit/provider/macauthorization_spec.rb b/spec/unit/provider/macauthorization_spec.rb
index a76f917f7..dbe36a04b 100755
--- a/spec/unit/provider/macauthorization_spec.rb
+++ b/spec/unit/provider/macauthorization_spec.rb
@@ -1,147 +1,152 @@
 #!/usr/bin/env rspec
 #
 # Unit testing for the macauthorization provider
 #
 
 require 'spec_helper'
 
 require 'puppet'
 require 'facter/util/plist'
 
 provider_class = Puppet::Type.type(:macauthorization).provider(:macauthorization)
 
 describe provider_class do
 
   before :each do
     # Create a mock resource
     @resource = stub 'resource'
 
     @authname = "foo.spam.eggs.puppettest"
     @authplist = {}
 
     @rules = {@authname => @authplist}
 
     authdb = {}
     authdb["rules"] = { "foorule" => "foo" }
     authdb["rights"] = { "fooright" => "foo" }
 
     # Stub out Plist::parse_xml
     Plist.stubs(:parse_xml).returns(authdb)
 
     # A catch all; no parameters set
     @resource.stubs(:[]).returns(nil)
 
     # But set name, ensure
     @resource.stubs(:[]).with(:name).returns @authname
     @resource.stubs(:[]).with(:ensure).returns :present
     @resource.stubs(:ref).returns "MacAuthorization[#{@authname}]"
 
     @provider = provider_class.new(@resource)
   end
 
   it "should have a create method" do
     @provider.should respond_to(:create)
   end
 
   it "should have a destroy method" do
     @provider.should respond_to(:destroy)
   end
 
   it "should have an exists? method" do
     @provider.should respond_to(:exists?)
   end
 
   it "should have a flush method" do
     @provider.should respond_to(:flush)
   end
 
   properties = [  :allow_root, :authenticate_user, :auth_class, :comment,
             :group, :k_of_n, :mechanisms, :rule, :session_owner,
             :shared, :timeout, :tries, :auth_type ]
 
   properties.each do |prop|
     it "should have a #{prop.to_s} method" do
       @provider.should respond_to(prop.to_s)
     end
 
     it "should have a #{prop.to_s}= method" do
       @provider.should respond_to(prop.to_s + "=")
     end
   end
 
   describe "when destroying a right" do
     before :each do
       @resource.stubs(:[]).with(:auth_type).returns(:right)
     end
 
     it "should call the internal method destroy_right" do
       @provider.expects(:destroy_right)
       @provider.destroy
     end
     it "should call the external command 'security authorizationdb remove @authname" do
       @provider.expects(:security).with("authorizationdb", :remove, @authname)
       @provider.destroy
     end
   end
 
   describe "when destroying a rule" do
     before :each do
       @resource.stubs(:[]).with(:auth_type).returns(:rule)
     end
 
     it "should call the internal method destroy_rule" do
       @provider.expects(:destroy_rule)
       @provider.destroy
     end
   end
 
   describe "when flushing a right" do
     before :each do
       @resource.stubs(:[]).with(:auth_type).returns(:right)
     end
 
     it "should call the internal method flush_right" do
       @provider.expects(:flush_right)
       @provider.flush
     end
 
     it "should call the internal method set_right" do
+      @provider.expects(:execute).with { |cmds, args|
+        cmds.include?("read") and
+        cmds.include?(@authname) and
+        args[:combine] == false
+      }.once
       @provider.expects(:set_right)
       @provider.flush
     end
 
     it "should read and write to the auth database with the right arguments" do
       @provider.expects(:execute).with { |cmds, args|
         cmds.include?("read") and
         cmds.include?(@authname) and
         args[:combine] == false
       }.once
 
       @provider.expects(:execute).with { |cmds, args|
         cmds.include?("write") and
         cmds.include?(@authname) and
         args[:combine] == false and
         args[:stdinfile] != nil
       }.once
       @provider.flush
     end
 
   end
 
   describe "when flushing a rule" do
     before :each do
       @resource.stubs(:[]).with(:auth_type).returns(:rule)
     end
 
     it "should call the internal method flush_rule" do
       @provider.expects(:flush_rule)
       @provider.flush
     end
 
     it "should call the internal method set_rule" do
       @provider.expects(:set_rule)
       @provider.flush
     end
   end
 
 end
diff --git a/spec/unit/provider/service/smf_spec.rb b/spec/unit/provider/service/smf_spec.rb
index 5212d540a..fd7d50e3a 100755
--- a/spec/unit/provider/service/smf_spec.rb
+++ b/spec/unit/provider/service/smf_spec.rb
@@ -1,137 +1,138 @@
 #!/usr/bin/env rspec
 #
 # Unit testing for the SMF service Provider
 #
 # author Dominic Cleal
 #
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:service).provider(:smf)
 
 describe provider_class do
 
   before(:each) do
     # Create a mock resource
     @resource = Puppet::Type.type(:service).new(
       :name => "/system/myservice", :ensure => :running, :enable => :true)
     @provider = provider_class.new(@resource)
 
     FileTest.stubs(:file?).with('/usr/sbin/svcadm').returns true
     FileTest.stubs(:executable?).with('/usr/sbin/svcadm').returns true
     FileTest.stubs(:file?).with('/usr/bin/svcs').returns true
     FileTest.stubs(:executable?).with('/usr/bin/svcs').returns true
   end
 
   it "should have a restart method" do
     @provider.should respond_to(:restart)
   end
 
   it "should have a restartcmd method" do
     @provider.should respond_to(:restartcmd)
   end
 
   it "should have a start method" do
     @provider.should respond_to(:start)
   end
 
   it "should have a stop method" do
     @provider.should respond_to(:stop)
   end
 
   it "should have an enabled? method" do
     @provider.should respond_to(:enabled?)
   end
 
   it "should have an enable method" do
     @provider.should respond_to(:enable)
   end
 
   it "should have a disable method" do
     @provider.should respond_to(:disable)
   end
 
   describe "when checking status" do
     it "should call the external command 'svcs /system/myservice' once" do
       @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.status
     end
     it "should return stopped if svcs can't find the service" do
       @provider.stubs(:svcs).raises(Puppet::ExecutionFailure.new("no svc found"))
       @provider.status.should == :stopped
     end
     it "should return running if online in svcs output" do
       @provider.stubs(:svcs).returns("online\t-")
       @provider.status.should == :running
     end
     it "should return stopped if disabled in svcs output" do
       @provider.stubs(:svcs).returns("disabled\t-")
       @provider.status.should == :stopped
     end
     it "should return maintenance if in maintenance in svcs output" do
       @provider.stubs(:svcs).returns("maintenance\t-")
       @provider.status.should == :maintenance
     end
     it "should return target state if transitioning in svcs output" do
       @provider.stubs(:svcs).returns("online\tdisabled")
       @provider.status.should == :stopped
     end
     it "should throw error if it's a legacy service in svcs output" do
       @provider.stubs(:svcs).returns("legacy_run\t-")
       lambda { @provider.status }.should raise_error(Puppet::Error, "Cannot manage legacy services through SMF")
     end
   end
 
   describe "when starting" do
     it "should enable the service if it is not enabled" do
       @provider.expects(:status).returns :stopped
       @provider.expects(:texecute)
       @provider.start
     end
 
     it "should always execute external command 'svcadm enable /system/myservice'" do
       @provider.stubs(:status).returns :running
       @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "/system/myservice"], true)
       @provider.start
     end
 
     it "should execute external command 'svcadm clear /system/myservice' if in maintenance" do
       @provider.stubs(:status).returns :maintenance
       @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
       @provider.start
     end
   end
 
   describe "when starting a service with a manifest" do
     before(:each) do
       @resource = Puppet::Type.type(:service).new(:name => "/system/myservice", :ensure => :running, :enable => :true, :manifest => "/tmp/myservice.xml")
       @provider = provider_class.new(@resource)
       $CHILD_STATUS.stubs(:exitstatus).returns(1)
     end
 
     it "should import the manifest if service is missing" do
       @provider.expects(:svccfg).with(:import, "/tmp/myservice.xml")
       @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "/system/myservice"], true)
+      @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.start
     end
 
     it "should handle failures if importing a manifest" do
       @provider.expects(:svccfg).raises(Puppet::ExecutionFailure.new("can't svccfg import"))
       lambda { @provider.start }.should raise_error(Puppet::Error, "Cannot config /system/myservice to enable it: can't svccfg import")
     end
   end
 
   describe "when stopping" do
     it "should execute external command 'svcadm disable /system/myservice'" do
       @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, "/system/myservice"], true)
       @provider.stop
     end
   end
 
   describe "when restarting" do
     it "should call 'svcadm restart /system/myservice'" do
       @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, "/system/myservice"], true)
       @provider.restart
     end
   end
 
 end
diff --git a/spec/unit/type/file/content_spec.rb b/spec/unit/type/file/content_spec.rb
index 6a2f3f4b3..04ec48555 100755
--- a/spec/unit/type/file/content_spec.rb
+++ b/spec/unit/type/file/content_spec.rb
@@ -1,435 +1,436 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 content = Puppet::Type.type(:file).attrclass(:content)
 describe content do
   include PuppetSpec::Files
   before do
     @filename = tmpfile('testfile')
     @resource = Puppet::Type.type(:file).new :path => @filename
     File.open(@filename, 'w') {|f| f.write "initial file content"}
     content.stubs(:standalone?).returns(false)
   end
 
   describe "when determining the checksum type" do
     it "should use the type specified in the source checksum if a source is set" do
       @resource[:source] = "/foo"
       @resource.parameter(:source).expects(:checksum).returns "{md5lite}eh"
 
       @content = content.new(:resource => @resource)
       @content.checksum_type.should == :md5lite
     end
 
     it "should use the type specified by the checksum parameter if no source is set" do
       @resource[:checksum] = :md5lite
 
       @content = content.new(:resource => @resource)
       @content.checksum_type.should == :md5lite
     end
   end
 
   describe "when determining the actual content to write" do
     it "should use the set content if available" do
       @content = content.new(:resource => @resource)
       @content.should = "ehness"
       @content.actual_content.should == "ehness"
     end
 
     it "should not use the content from the source if the source is set" do
       source = mock 'source'
 
       @resource.expects(:parameter).never.with(:source).returns source
 
       @content = content.new(:resource => @resource)
       @content.actual_content.should be_nil
     end
   end
 
   describe "when setting the desired content" do
     it "should make the actual content available via an attribute" do
       @content = content.new(:resource => @resource)
       @content.stubs(:checksum_type).returns "md5"
       @content.should = "this is some content"
 
       @content.actual_content.should == "this is some content"
     end
 
     it "should store the checksum as the desired content" do
       @content = content.new(:resource => @resource)
       digest = Digest::MD5.hexdigest("this is some content")
 
       @content.stubs(:checksum_type).returns "md5"
       @content.should = "this is some content"
 
       @content.should.must == "{md5}#{digest}"
     end
 
     it "should not checksum 'absent'" do
       @content = content.new(:resource => @resource)
       @content.should = :absent
 
       @content.should.must == :absent
     end
 
     it "should accept a checksum as the desired content" do
       @content = content.new(:resource => @resource)
       digest = Digest::MD5.hexdigest("this is some content")
 
       string = "{md5}#{digest}"
       @content.should = string
 
       @content.should.must == string
     end
   end
 
   describe "when retrieving the current content" do
     it "should return :absent if the file does not exist" do
       @content = content.new(:resource => @resource)
       @resource.expects(:stat).returns nil
 
       @content.retrieve.should == :absent
     end
 
     it "should not manage content on directories" do
       @content = content.new(:resource => @resource)
 
       stat = mock 'stat', :ftype => "directory"
       @resource.expects(:stat).returns stat
 
       @content.retrieve.should be_nil
     end
 
     it "should not manage content on links" do
       @content = content.new(:resource => @resource)
 
       stat = mock 'stat', :ftype => "link"
       @resource.expects(:stat).returns stat
 
       @content.retrieve.should be_nil
     end
 
     it "should always return the checksum as a string" do
       @content = content.new(:resource => @resource)
       @resource[:checksum] = :mtime
 
       stat = mock 'stat', :ftype => "file"
       @resource.expects(:stat).returns stat
 
       time = Time.now
       @resource.parameter(:checksum).expects(:mtime_file).with(@resource[:path]).returns time
 
       @content.retrieve.should == "{mtime}#{time}"
     end
 
     it "should return the checksum of the file if it exists and is a normal file" do
       @content = content.new(:resource => @resource)
       stat = mock 'stat', :ftype => "file"
       @resource.expects(:stat).returns stat
       @resource.parameter(:checksum).expects(:md5_file).with(@resource[:path]).returns "mysum"
 
       @content.retrieve.should == "{md5}mysum"
     end
   end
 
   describe "when testing whether the content is in sync" do
     before do
       @resource[:ensure] = :file
       @content = content.new(:resource => @resource)
     end
 
     it "should return true if the resource shouldn't be a regular file" do
       @resource.expects(:should_be_file?).returns false
       @content.should = "foo"
       @content.must be_safe_insync("whatever")
     end
 
     it "should return false if the current content is :absent" do
       @content.should = "foo"
       @content.should_not be_safe_insync(:absent)
     end
 
     it "should return false if the file should be a file but is not present" do
       @resource.expects(:should_be_file?).returns true
       @content.should = "foo"
 
       @content.should_not be_safe_insync(:absent)
     end
 
     describe "and the file exists" do
       before do
         @resource.stubs(:stat).returns mock("stat")
       end
 
       it "should return false if the current contents are different from the desired content" do
         @content.should = "some content"
         @content.should_not be_safe_insync("other content")
       end
 
       it "should return true if the sum for the current contents is the same as the sum for the desired content" do
         @content.should = "some content"
         @content.must be_safe_insync("{md5}" + Digest::MD5.hexdigest("some content"))
       end
 
       describe "and Puppet[:show_diff] is set" do
         before do
           Puppet[:show_diff] = true
         end
 
         it "should display a diff if the current contents are different from the desired content" do
           @content.should = "some content"
           @content.expects(:diff).returns("my diff").once
           @content.expects(:print).with("my diff").once
 
           @content.safe_insync?("other content")
         end
 
         it "should not display a diff if the sum for the current contents is the same as the sum for the desired content" do
           @content.should = "some content"
           @content.expects(:diff).never
 
           @content.safe_insync?("{md5}" + Digest::MD5.hexdigest("some content"))
         end
       end
     end
 
     describe "and :replace is false" do
       before do
         @resource.stubs(:replace?).returns false
       end
 
       it "should be insync if the file exists and the content is different" do
         @resource.stubs(:stat).returns mock('stat')
 
         @content.must be_safe_insync("whatever")
       end
 
       it "should be insync if the file exists and the content is right" do
         @resource.stubs(:stat).returns mock('stat')
 
         @content.must be_safe_insync("something")
       end
 
       it "should not be insync if the file does not exist" do
         @content.should = "foo"
         @content.should_not be_safe_insync(:absent)
       end
     end
   end
 
   describe "when changing the content" do
     before do
       @content = content.new(:resource => @resource)
       @content.should = "some content"
 
       @resource.stubs(:[]).with(:path).returns "/boo"
       @resource.stubs(:stat).returns "eh"
     end
 
     it "should use the file's :write method to write the content" do
       @resource.expects(:write).with(:content)
 
       @content.sync
     end
 
     it "should return :file_changed if the file already existed" do
       @resource.expects(:stat).returns "something"
       @resource.stubs(:write)
       @content.sync.should == :file_changed
     end
 
     it "should return :file_created if the file did not exist" do
       @resource.expects(:stat).returns nil
       @resource.stubs(:write)
       @content.sync.should == :file_created
     end
   end
 
   describe "when writing" do
     before do
       @content = content.new(:resource => @resource)
     end
 
     it "should attempt to read from the filebucket if no actual content nor source exists" do
       @fh = File.open(@filename, 'w')
       @content.should = "{md5}foo"
       @content.resource.bucket.class.any_instance.stubs(:getfile).returns "foo"
       @content.write(@fh)
+      @fh.close
     end
 
     describe "from actual content" do
       before(:each) do
         @content.stubs(:actual_content).returns("this is content")
       end
 
       it "should write to the given file handle" do
         @fh.expects(:print).with("this is content")
         @content.write(@fh)
       end
 
       it "should return the current checksum value" do
         @resource.parameter(:checksum).expects(:sum_stream).returns "checksum"
         @content.write(@fh).should == "checksum"
       end
     end
 
     describe "from a file bucket" do
       it "should fail if a file bucket cannot be retrieved" do
         @content.should = "{md5}foo"
         @content.resource.expects(:bucket).returns nil
         lambda { @content.write(@fh) }.should raise_error(Puppet::Error)
       end
 
       it "should fail if the file bucket cannot find any content" do
         @content.should = "{md5}foo"
         bucket = stub 'bucket'
         @content.resource.expects(:bucket).returns bucket
         bucket.expects(:getfile).with("foo").raises "foobar"
         lambda { @content.write(@fh) }.should raise_error(Puppet::Error)
       end
 
       it "should write the returned content to the file" do
         @content.should = "{md5}foo"
         bucket = stub 'bucket'
         @content.resource.expects(:bucket).returns bucket
         bucket.expects(:getfile).with("foo").returns "mycontent"
 
         @fh.expects(:print).with("mycontent")
         @content.write(@fh)
       end
     end
 
     describe "from local source", :fails_on_windows => true do
       before(:each) do
         @resource = Puppet::Type.type(:file).new :path => @filename, :backup => false
         @sourcename = tmpfile('source')
         @source_content = "source file content"*10000
         @sourcefile = File.open(@sourcename, 'w') {|f| f.write @source_content}
 
         @content = @resource.newattr(:content)
         @source = @resource.newattr(:source)
         @source.stubs(:metadata).returns stub_everything('metadata', :source => @sourcename, :ftype => 'file')
       end
 
       it "should copy content from the source to the file" do
         @resource.write(@source)
         File.read(@filename).should == @source_content
       end
 
       it "should return the checksum computed" do
         File.open(@filename, 'w') do |file|
           @content.write(file).should == "{md5}#{Digest::MD5.hexdigest(@source_content)}"
         end
       end
     end
 
     describe "from remote source" do
       before(:each) do
         @resource = Puppet::Type.type(:file).new :path => @filename, :backup => false
         @response = stub_everything 'response', :code => "200"
         @source_content = "source file content"*10000
         @response.stubs(:read_body).multiple_yields(*(["source file content"]*10000))
 
         @conn = stub_everything 'connection'
         @conn.stubs(:request_get).yields(@response)
         Puppet::Network::HttpPool.stubs(:http_instance).returns @conn
 
         @content = @resource.newattr(:content)
         @sourcename = "puppet:///test/foo"
         @source = @resource.newattr(:source)
         @source.stubs(:metadata).returns stub_everything('metadata', :source => @sourcename, :ftype => 'file')
       end
 
       it "should write the contents to the file" do
         @resource.write(@source)
         File.read(@filename).should == @source_content
       end
 
       it "should not write anything if source is not found" do
         @response.stubs(:code).returns("404")
         lambda {@resource.write(@source)}.should raise_error(Net::HTTPError) { |e| e.message =~ /404/ }
         File.read(@filename).should == "initial file content"
       end
 
       it "should raise an HTTP error in case of server error" do
         @response.stubs(:code).returns("500")
         lambda { @content.write(@fh) }.should raise_error { |e| e.message.include? @source_content }
       end
 
       it "should return the checksum computed" do
         File.open(@filename, 'w') do |file|
           @content.write(file).should == "{md5}#{Digest::MD5.hexdigest(@source_content)}"
         end
       end
     end
 
     # These are testing the implementation rather than the desired behaviour; while that bites, there are a whole
     # pile of other methods in the File type that depend on intimate details of this implementation and vice-versa.
     # If these blow up, you are gonna have to review the callers to make sure they don't explode! --daniel 2011-02-01
     describe "each_chunk_from should work" do
       before do
         @content = content.new(:resource => @resource)
       end
 
       it "when content is a string" do
         @content.each_chunk_from('i_am_a_string') { |chunk| chunk.should == 'i_am_a_string' }
       end
 
       # The following manifest is a case where source and content.should are both set
       # file { "/tmp/mydir" :
       #   source  => '/tmp/sourcedir',
       #   recurse => true,
       # }
       it "when content checksum comes from source" do
         source_param = Puppet::Type.type(:file).attrclass(:source)
         source = source_param.new(:resource => @resource)
         @content.should = "{md5}123abcd"
 
         @content.expects(:chunk_file_from_source).returns('from_source')
         @content.each_chunk_from(source) { |chunk| chunk.should == 'from_source' }
       end
 
       it "when no content, source, but ensure present" do
         @resource[:ensure] = :present
         @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       # you might do this if you were just auditing
       it "when no content, source, but ensure file" do
         @resource[:ensure] = :file
         @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       it "when source_or_content is nil and content not a checksum" do
         @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       # the content is munged so that if it's a checksum nil gets passed in
       it "when content is a checksum it should try to read from filebucket" do
         @content.should = "{md5}123abcd"
         @content.expects(:read_file_from_filebucket).once.returns('im_a_filebucket')
         @content.each_chunk_from(nil) { |chunk| chunk.should == 'im_a_filebucket' }
       end
 
       it "when running as puppet apply" do
         @content.class.expects(:standalone?).returns true
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:content).once.returns :whoo
         @content.each_chunk_from(source_or_content) { |chunk| chunk.should == :whoo }
       end
 
       it "when running from source with a local file" do
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:local?).returns true
         @content.expects(:chunk_file_from_disk).with(source_or_content).once.yields 'woot'
         @content.each_chunk_from(source_or_content) { |chunk| chunk.should == 'woot' }
       end
 
       it "when running from source with a remote file" do
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:local?).returns false
         @content.expects(:chunk_file_from_source).with(source_or_content).once.yields 'woot'
         @content.each_chunk_from(source_or_content) { |chunk| chunk.should == 'woot' }
       end
     end
   end
 end