diff --git a/spec/unit/transaction/report_spec.rb b/spec/unit/transaction/report_spec.rb
index 4f3c90d88..4b9e06cad 100755
--- a/spec/unit/transaction/report_spec.rb
+++ b/spec/unit/transaction/report_spec.rb
@@ -1,230 +1,234 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/transaction/report'
 
 describe Puppet::Transaction::Report do
+    before do
+        Puppet::Util::Storage.stubs(:store)
+    end
+
     it "should set its host name to the certname" do
         Puppet.settings.expects(:value).with(:certname).returns "myhost"
         Puppet::Transaction::Report.new.host.should == "myhost"
     end
 
     it "should return its host name as its name" do
         r = Puppet::Transaction::Report.new
         r.name.should == r.host
     end
 
     it "should create an initialization timestamp" do
         Time.expects(:now).returns "mytime"
         Puppet::Transaction::Report.new.time.should == "mytime"
     end
 
     describe "when accepting logs" do
         before do
             @report = Puppet::Transaction::Report.new
         end
 
         it "should add new logs to the log list" do
             @report << "log"
             @report.logs[-1].should == "log"
         end
 
         it "should return self" do
             r = @report << "log"
             r.should equal(@report)
         end
     end
 
     describe "when accepting resource statuses" do
         before do
             @report = Puppet::Transaction::Report.new
         end
 
         it "should add each status to its status list" do
             status = stub 'status', :resource => "foo"
             @report.add_resource_status status
             @report.resource_statuses["foo"].should equal(status)
         end
     end
 
     describe "when using the indirector" do
         it "should redirect :find to the indirection" do
             @indirection = stub 'indirection', :name => :report
             Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
             @indirection.expects(:find)
             Puppet::Transaction::Report.find(:report)
         end
 
         it "should redirect :save to the indirection" do
             Facter.stubs(:value).returns("eh")
             @indirection = stub 'indirection', :name => :report
             Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
             report = Puppet::Transaction::Report.new
             @indirection.expects(:save)
             report.save
         end
 
         it "should default to the 'processor' terminus" do
             Puppet::Transaction::Report.indirection.terminus_class.should == :processor
         end
 
         it "should delegate its name attribute to its host method" do
             report = Puppet::Transaction::Report.new
             report.expects(:host).returns "me"
             report.name.should == "me"
         end
 
         after do
             Puppet::Util::Cacher.expire
         end
     end
 
     describe "when computing exit status" do
         it "should produce 2 if changes are present" do
             report = Puppet::Transaction::Report.new
             report.add_metric("changes", {:total => 1})
             report.add_metric("resources", {:failed => 0})
             report.exit_status.should == 2
         end
 
         it "should produce 4 if failures are present" do
             report = Puppet::Transaction::Report.new
             report.add_metric("changes", {:total => 0})
             report.add_metric("resources", {:failed => 1})
             report.exit_status.should == 4
         end
 
         it "should produce 6 if both changes and failures are present" do
             report = Puppet::Transaction::Report.new
             report.add_metric("changes", {:total => 1})
             report.add_metric("resources", {:failed => 1})
             report.exit_status.should == 6
         end
     end
 
     describe "when calculating metrics" do
         before do
             @report = Puppet::Transaction::Report.new
         end
 
         def metric(name, value)
             if metric = @report.metrics[name.to_s]
                 metric[value]
             else
                 nil
             end
         end
 
         def add_statuses(count, type = :file)
             3.times do |i|
                 status = Puppet::Resource::Status.new(Puppet::Type.type(type).new(:title => "/my/path#{i}"))
                 yield status if block_given?
                 @report.add_resource_status status
             end
         end
 
 
         [:time, :resources, :changes, :events].each do |type|
             it "should add #{type} metrics" do
                 @report.calculate_metrics
                 @report.metrics[type.to_s].should be_instance_of(Puppet::Transaction::Metric)
             end
         end
 
         describe "for resources" do
             it "should provide the total number of resources" do
                 add_statuses(3)
 
                 @report.calculate_metrics
                 metric(:resources, :total).should == 3
             end
 
             Puppet::Resource::Status::STATES.each do |state|
                 it "should provide the number of #{state} resources as determined by the status objects" do
                     add_statuses(3) { |status| status.send(state.to_s + "=", true) }
 
                     @report.calculate_metrics
                     metric(:resources, state).should == 3
                 end
             end
         end
 
         describe "for changes" do
             it "should provide the number of changes from the resource statuses" do
                 add_statuses(3) { |status| status.change_count = 3 }
                 @report.calculate_metrics
                 metric(:changes, :total).should == 9
             end
         end
 
         describe "for times" do
             it "should provide the total amount of time for each resource type" do
                 add_statuses(3, :file) do |status|
                     status.evaluation_time = 1 
                 end
                 add_statuses(3, :exec) do |status|
                     status.evaluation_time = 2 
                 end
                 add_statuses(3, :mount) do |status|
                     status.evaluation_time = 3 
                 end
 
                 @report.calculate_metrics
 
                 metric(:time, "file").should == 3
                 metric(:time, "exec").should == 6
                 metric(:time, "mount").should == 9
             end
 
             it "should add any provided times from external sources" do
                 @report.add_times :foobar, 50
                 @report.calculate_metrics
                 metric(:time, "foobar").should == 50
             end
         end
 
         describe "for events" do
             it "should provide the total number of events" do
                 add_statuses(3) do |status|
                     3.times { |i| status.add_event(Puppet::Transaction::Event.new) }
                 end
                 @report.calculate_metrics
                 metric(:events, :total).should == 9
             end
 
             Puppet::Transaction::Event::EVENT_STATUSES.each do |status_name|
                 it "should provide the number of #{status_name} events" do
                     add_statuses(3) do |status|
                         3.times do |i|
                             event = Puppet::Transaction::Event.new
                             event.status = status_name
                             status.add_event(event)
                         end
                     end
 
                     @report.calculate_metrics
                     metric(:events, status_name).should == 9
                 end
             end
         end
     end
 
     describe "when producing a summary" do
         before do
             resource = Puppet::Type.type(:notify).new(:name => "testing")
             catalog = Puppet::Resource::Catalog.new
             catalog.add_resource resource
             trans = catalog.apply
 
             @report = trans.report
             @report.calculate_metrics
         end
 
         %w{Changes Total Resources}.each do |main|
             it "should include information on #{main} in the summary" do
                 @report.summary.should be_include(main)
             end
         end
     end
 end
diff --git a/spec/unit/type/package_spec.rb b/spec/unit/type/package_spec.rb
index 7cbd76aa7..02f3f9fbd 100755
--- a/spec/unit/type/package_spec.rb
+++ b/spec/unit/type/package_spec.rb
@@ -1,241 +1,240 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:package) do
     before do
         Puppet::Util::Storage.stubs(:store)
     end
 
-
     it "should have an :installable feature that requires the :install method" do
         Puppet::Type.type(:package).provider_feature(:installable).methods.should == [:install]
     end
 
     it "should have an :uninstallable feature that requires the :uninstall method" do
         Puppet::Type.type(:package).provider_feature(:uninstallable).methods.should == [:uninstall]
     end
 
     it "should have an :upgradeable feature that requires :update and :latest methods" do
         Puppet::Type.type(:package).provider_feature(:upgradeable).methods.should == [:update, :latest]
     end
 
     it "should have a :purgeable feature that requires the :purge latest method" do
         Puppet::Type.type(:package).provider_feature(:purgeable).methods.should == [:purge]
     end
 
     it "should have a :versionable feature" do
         Puppet::Type.type(:package).provider_feature(:versionable).should_not be_nil
     end
 
     it "should default to being installed" do
         pkg = Puppet::Type.type(:package).new(:name => "yay")
         pkg.should(:ensure).should == :present
     end
 
     describe "when validating attributes" do
         [:name, :source, :instance, :status, :adminfile, :responsefile, :configfiles, :category, :platform, :root, :vendor, :description, :allowcdrom].each do |param|
             it "should have a #{param} parameter" do
                 Puppet::Type.type(:package).attrtype(param).should == :param
             end
         end
 
         it "should have an ensure property" do
             Puppet::Type.type(:package).attrtype(:ensure).should == :property
         end
     end
 
     describe "when validating attribute values" do
         before do
             @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil
             Puppet::Type.type(:package).defaultprovider.expects(:new).returns(@provider)
         end
 
         it "should support :present as a value to :ensure" do
             Puppet::Type.type(:package).new(:name => "yay", :ensure => :present)
         end
 
         it "should alias :installed to :present as a value to :ensure" do
             pkg = Puppet::Type.type(:package).new(:name => "yay", :ensure => :installed)
             pkg.should(:ensure).should == :present
         end
 
         it "should support :absent as a value to :ensure" do
             Puppet::Type.type(:package).new(:name => "yay", :ensure => :absent)
         end
 
         it "should support :purged as a value to :ensure if the provider has the :purgeable feature" do
             @provider.expects(:satisfies?).with([:purgeable]).returns(true)
             Puppet::Type.type(:package).new(:name => "yay", :ensure => :purged)
         end
 
         it "should not support :purged as a value to :ensure if the provider does not have the :purgeable feature" do
             @provider.expects(:satisfies?).with([:purgeable]).returns(false)
             proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => :purged) }.should raise_error(Puppet::Error)
         end
 
         it "should support :latest as a value to :ensure if the provider has the :upgradeable feature" do
             @provider.expects(:satisfies?).with([:upgradeable]).returns(true)
             Puppet::Type.type(:package).new(:name => "yay", :ensure => :latest)
         end
 
         it "should not support :latest as a value to :ensure if the provider does not have the :upgradeable feature" do
             @provider.expects(:satisfies?).with([:upgradeable]).returns(false)
             proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => :latest) }.should raise_error(Puppet::Error)
         end
 
         it "should support version numbers as a value to :ensure if the provider has the :versionable feature" do
             @provider.expects(:satisfies?).with([:versionable]).returns(true)
             Puppet::Type.type(:package).new(:name => "yay", :ensure => "1.0")
         end
 
         it "should not support version numbers as a value to :ensure if the provider does not have the :versionable feature" do
             @provider.expects(:satisfies?).with([:versionable]).returns(false)
             proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => "1.0") }.should raise_error(Puppet::Error)
         end
 
         it "should accept any string as an argument to :source" do
             proc { Puppet::Type.type(:package).new(:name => "yay", :source => "stuff") }.should_not raise_error(Puppet::Error)
         end
     end
 
     module PackageEvaluationTesting
         def setprops(properties)
             @provider.stubs(:properties).returns(properties)
         end
     end
 
     describe Puppet::Type.type(:package) do
         before :each do
             @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
             Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
             Puppet::Type.type(:package).defaultprovider.stubs(:instances).returns([])
             @package = Puppet::Type.type(:package).new(:name => "yay")
 
             @catalog = Puppet::Resource::Catalog.new
             @catalog.add_resource(@package)
         end
 
         describe Puppet::Type.type(:package), "when it should be purged" do
             include PackageEvaluationTesting
 
             before { @package[:ensure] = :purged }
 
             it "should do nothing if it is :purged" do
                 @provider.expects(:properties).returns(:ensure => :purged)
                 @catalog.apply
             end
 
             [:absent, :installed, :present, :latest].each do |state|
                 it "should purge if it is #{state.to_s}" do
                     @provider.stubs(:properties).returns(:ensure => state)
                     @provider.expects(:purge)
                     @catalog.apply
                 end
             end
         end
 
         describe Puppet::Type.type(:package), "when it should be absent" do
             include PackageEvaluationTesting
 
             before { @package[:ensure] = :absent }
 
             [:purged, :absent].each do |state|
                 it "should do nothing if it is #{state.to_s}" do
                     @provider.expects(:properties).returns(:ensure => state)
                     @catalog.apply
                 end
             end
 
             [:installed, :present, :latest].each do |state|
                 it "should uninstall if it is #{state.to_s}" do
                     @provider.stubs(:properties).returns(:ensure => state)
                     @provider.expects(:uninstall)
                     @catalog.apply
                 end
             end
         end
 
         describe Puppet::Type.type(:package), "when it should be present" do
             include PackageEvaluationTesting
 
             before { @package[:ensure] = :present }
 
             [:present, :latest, "1.0"].each do |state|
                 it "should do nothing if it is #{state.to_s}" do
                     @provider.expects(:properties).returns(:ensure => state)
                     @catalog.apply
                 end
             end
 
             [:purged, :absent].each do |state|
                 it "should install if it is #{state.to_s}" do
                     @provider.stubs(:properties).returns(:ensure => state)
                     @provider.expects(:install)
                     @catalog.apply
                 end
             end
         end
 
         describe Puppet::Type.type(:package), "when it should be latest" do
             include PackageEvaluationTesting
 
             before { @package[:ensure] = :latest }
 
             [:purged, :absent].each do |state|
                 it "should upgrade if it is #{state.to_s}" do
                     @provider.stubs(:properties).returns(:ensure => state)
                     @provider.expects(:update)
                     @catalog.apply
                 end
             end
 
             it "should upgrade if the current version is not equal to the latest version" do
                 @provider.stubs(:properties).returns(:ensure => "1.0")
                 @provider.stubs(:latest).returns("2.0")
                 @provider.expects(:update)
                 @catalog.apply
             end
 
             it "should do nothing if it is equal to the latest version" do
                 @provider.stubs(:properties).returns(:ensure => "1.0")
                 @provider.stubs(:latest).returns("1.0")
                 @provider.expects(:update).never
                 @catalog.apply
             end
 
             it "should do nothing if the provider returns :present as the latest version" do
                 @provider.stubs(:properties).returns(:ensure => :present)
                 @provider.stubs(:latest).returns("1.0")
                 @provider.expects(:update).never
                 @catalog.apply
             end
         end
 
         describe Puppet::Type.type(:package), "when it should be a specific version" do
             include PackageEvaluationTesting
 
             before { @package[:ensure] = "1.0" }
 
             [:purged, :absent].each do |state|
                 it "should install if it is #{state.to_s}" do
                     @provider.stubs(:properties).returns(:ensure => state)
                     @provider.expects(:install)
                     @catalog.apply
                 end
             end
 
             it "should do nothing if the current version is equal to the desired version" do
                 @provider.stubs(:properties).returns(:ensure => "1.0")
                 @provider.expects(:install).never
                 @catalog.apply
             end
 
             it "should install if the current version is not equal to the specified version" do
                 @provider.stubs(:properties).returns(:ensure => "2.0")
                 @provider.expects(:install)
                 @catalog.apply
             end
         end
     end
 end