diff --git a/spec/unit/parser/collector_spec.rb b/spec/unit/parser/collector_spec.rb
index 251fec78a..1bb68a0f7 100755
--- a/spec/unit/parser/collector_spec.rb
+++ b/spec/unit/parser/collector_spec.rb
@@ -1,437 +1,438 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/rails'
 require 'puppet/parser/collector'
 
 describe Puppet::Parser::Collector, "when initializing" do
   before do
     @scope = mock 'scope'
     @resource_type = 'resource_type'
     @form = :exported
     @vquery = mock 'vquery'
     @equery = mock 'equery'
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, @form)
   end
 
   it "should require a scope" do
     @collector.scope.should equal(@scope)
   end
 
   it "should require a resource type" do
     @collector.type.should == 'Resource_type'
   end
 
   it "should only accept :virtual or :exported as the collector form" do
     proc { @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @vquery, @equery, :other) }.should raise_error(ArgumentError)
   end
 
   it "should accept an optional virtual query" do
     @collector.vquery.should equal(@vquery)
   end
 
   it "should accept an optional exported query" do
     @collector.equery.should equal(@equery)
   end
 
   it "should canonize the type name" do
     @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
     @collector.type.should == "Resource::Type"
   end
 
   it "should accept an optional resource override" do
     @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
     override = { :parameters => "whatever" }
     @collector.add_override(override)
     @collector.overrides.should equal(override)
   end
 
 end
 
 describe Puppet::Parser::Collector, "when collecting specific virtual resources" do
   before do
     @scope = mock 'scope'
     @vquery = mock 'vquery'
     @equery = mock 'equery'
+    @compiler = mock 'compiler'
 
     @collector = Puppet::Parser::Collector.new(@scope, "resource_type", @equery, @vquery, :virtual)
   end
 
   it "should not fail when it does not find any resources to collect" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     @scope.stubs(:findresource).returns(false)
     proc { @collector.evaluate }.should_not raise_error
   end
 
   it "should mark matched resources as non-virtual" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     one = stub_everything 'one'
     one.expects(:virtual=).with(false)
 
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
     @collector.evaluate
   end
 
   it "should return matched resources" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     one = stub_everything 'one'
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
     @collector.evaluate.should == [one]
   end
 
   it "should delete itself from the compile's collection list if it has found all of its resources" do
     @collector.resources = ["File[virtual1]"]
     one = stub_everything 'one'
     @compiler.expects(:delete_collection).with(@collector)
     @scope.expects(:compiler).returns(@compiler)
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @collector.evaluate
   end
 
   it "should not delete itself from the compile's collection list if it has unfound resources" do
     @collector.resources = ["File[virtual1]"]
     one = stub_everything 'one'
     @compiler.expects(:delete_collection).never
     @scope.stubs(:findresource).with("File[virtual1]").returns(nil)
     @collector.evaluate
   end
 end
 
 describe Puppet::Parser::Collector, "when collecting virtual and catalog resources" do
   before do
     @scope = mock 'scope'
     @compiler = mock 'compile'
     @scope.stubs(:compiler).returns(@compiler)
     @resource_type = "Mytype"
     @vquery = proc { |res| true }
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, nil, @vquery, :virtual)
   end
 
   it "should find all virtual resources matching the vquery" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should find all non-virtual resources matching the vquery" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => false
     two = stub_everything 'two', :type => "Mytype", :virtual? => false
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should mark all matched resources as non-virtual" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.evaluate
   end
 
   it "should return matched resources" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should return all resources of the correct type if there is no virtual query" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).with(false)
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, nil, nil, :virtual)
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should not return or mark resources of a different type" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => :other, :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).never
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one]
   end
 
   it "should create a resource with overridden parameters" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).with { |type, title, h|
       h[:parameters] == param
     }
 
     @collector.evaluate
   end
 
   it "should define a new allow all child_of? on overriden resource" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     source = stub 'source'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.add_override(:parameters => param, :source => source )
     Puppet::Parser::Resource.stubs(:new)
 
     source.expects(:meta_def).with { |name,block| name == :child_of? }
 
     @collector.evaluate
   end
 
 
   it "should not override already overriden resources for this same collection in a previous run" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).at_least(2).returns([one])
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).once.with { |type, title, h|
       h[:parameters] == param
     }
 
     @collector.evaluate
 
     @collector.evaluate
   end
 
   it "should not return resources that were collected in a previous run of this collector" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     @compiler.stubs(:resources).returns([one])
 
     @collector.evaluate
 
     @collector.evaluate.should be_false
   end
 
 
   it "should tell the compiler about the overriden resources" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
 
     one.expects(:virtual=).with(false)
     @compiler.expects(:resources).returns([one])
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.stubs(:new).returns("whatever")
 
     @compiler.expects(:add_override).with("whatever")
 
     @collector.evaluate
   end
 
   it "should not return or mark non-matching resources" do
     @collector.vquery = proc { |res| res.name == :one }
 
     one = stub_everything 'one', :name => :one, :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :name => :two, :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).never
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one]
   end
 end
 
 describe Puppet::Parser::Collector, "when collecting exported resources", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
   before do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
     @resource_type = "notify"
     @equery = ["title", "!=", ""]
     @vquery = proc { |r| true }
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type,
                                                @equery, @vquery, :exported)
   end
 
   it "should just return false if :storeconfigs is not enabled" do
     Puppet[:storeconfigs] = false
     @collector.evaluate.should be_false
   end
 
   context "with storeconfigs enabled" do
     before :each do
       setup_scratch_database
       Puppet[:storeconfigs] = true
       Puppet[:environment]  = "production"
       Puppet[:storeconfigs_backend] = "active_record"
     end
 
     it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do
       one = Puppet::Parser::Resource.new('notify', 'one',
                                          :virtual  => true,
                                          :exported => true,
                                          :scope    => @scope)
       two = Puppet::Parser::Resource.new('notify', 'two',
                                          :virtual  => true,
                                          :exported => true,
                                          :scope    => @scope)
 
       @compiler.resources << one
       @compiler.resources << two
 
       @collector.evaluate.should == [one, two]
       one.should_not be_virtual
       two.should_not be_virtual
 
       # REVISIT: Apparently we never actually marked local resources as
       # non-exported.  So, this is what the previous test asserted, and checking
       # what it claims to do causes test failures. --daniel 2011-08-23
     end
 
     it "should mark all returned resources as not virtual" do
       one = Puppet::Parser::Resource.new('notify', 'one',
                                          :virtual  => true,
                                          :exported => true,
                                          :scope    => @scope)
 
       @compiler.resources << one
 
       @collector.evaluate.should == [one]
       one.should_not be_virtual
     end
 
     it "should convert all found resources into parser resources if necessary" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       result = @collector.evaluate
       result.length.should == 1
       result.first.should be_an_instance_of Puppet::Parser::Resource
       result.first.type.should == 'Notify'
       result.first.title.should == 'whammo'
     end
 
     it "should leave parser resources alone" do
       resource = Puppet::Parser::Resource.new(:file, "/tmp/foo", :scope => @scope)
       resource2 = Puppet::Parser::Resource.new(:file, "/tmp/bar", :scope => @scope)
       resource.expects(:to_resource).never
       resource2.expects(:to_resource).never
 
       resources = [resource, resource2]
 
       Puppet::Resource.indirection.stubs(:search).returns resources
 
       @collector.evaluate.should == resources
     end
 
     it "should override all exported collected resources if collector has an override" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       param = Puppet::Parser::Resource::Param.
         new(:name => 'message', :value => 'howdy')
       @collector.add_override(:parameters => [param], :scope => @scope)
 
       got = @collector.evaluate
       got.first[:message].should == param.value
     end
 
     it "should store converted resources in the compile's resource list" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       @compiler.expects(:add_resource).with do |scope, resource|
         scope.should be_an_instance_of Puppet::Parser::Scope
         resource.type.should  == 'Notify'
         resource.title.should == 'whammo'
         true
       end
 
       @collector.evaluate
     end
 
     # This way one host doesn't store another host's resources as exported.
     it "should mark resources collected from the database as not exported" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       got = @collector.evaluate
       got.length.should == 1
       got.first.type.should == "Notify"
       got.first.title.should == "whammo"
       got.first.should_not be_exported
     end
 
     it "should fail if an equivalent resource already exists in the compile" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       local = Puppet::Parser::Resource.new('notify', 'whammo', :scope => @scope)
       @compiler.add_resource(@scope, local)
 
       expect { @collector.evaluate }.
         to raise_error Puppet::ParseError, /exists with the type and title/
     end
 
     it "should ignore exported resources that match already-collected resources" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       # One that we already collected...
       db = Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
       # ...and one we didn't.
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'boingy-boingy',
                 :exported => true)
 
       local = Puppet::Parser::Resource.new('notify', 'whammo',
                                            :scope        => @scope,
                                            :collector_id => db.id)
       @compiler.add_resource(@scope, local)
 
       got = nil
       expect { got = @collector.evaluate }.not_to raise_error(Puppet::ParseError)
       got.length.should == 1
       got.first.type.should == "Notify"
       got.first.title.should == "boingy-boingy"
     end
   end
 end
diff --git a/spec/unit/type/file/content_spec.rb b/spec/unit/type/file/content_spec.rb
index 025741f29..4641964a6 100755
--- a/spec/unit/type/file/content_spec.rb
+++ b/spec/unit/type/file/content_spec.rb
@@ -1,437 +1,439 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/network/http_pool'
 
 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] = File.expand_path("/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(:notice).with("\nmy 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, 'wb')
       @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)
+        fh = mock 'filehandle'
+        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)
+        fh = mock 'filehandle'
+        fh.expects(:print).with("mycontent")
+        @content.write(fh)
       end
     end
 
     describe "from local source" do
       before(:each) do
         @sourcename = tmpfile('source')
         @resource = Puppet::Type.type(:file).new :path => @filename, :backup => false, :source => @sourcename
 
         @source_content = "source file content\r\n"*10000
         @sourcefile = File.open(@sourcename, 'wb') {|f| f.write @source_content}
 
         @content = @resource.newattr(:content)
         @source = @resource.parameter :source #newattr(:source)
       end
 
       it "should copy content from the source to the file" do
         @resource.write(@source)
         IO.binread(@filename).should == @source_content
       end
 
       it "should return the checksum computed" do
         File.open(@filename, 'wb') 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\n"*10000
         @response.stubs(:read_body).multiple_yields(*(["source file content\n"]*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)
         IO.binread(@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