diff --git a/lib/puppet/application/apply.rb b/lib/puppet/application/apply.rb
index 59a95d35a..33a70ce8a 100644
--- a/lib/puppet/application/apply.rb
+++ b/lib/puppet/application/apply.rb
@@ -1,173 +1,157 @@
 require 'puppet/application'
 
 class Puppet::Application::Apply < Puppet::Application
 
   should_parse_config
 
   option("--debug","-d")
   option("--execute EXECUTE","-e") do |arg|
     options[:code] = arg
   end
   option("--loadclasses","-L")
   option("--verbose","-v")
   option("--use-nodes")
   option("--detailed-exitcodes")
 
   option("--apply catalog",  "-a catalog") do |arg|
     options[:catalog] = arg
   end
 
   option("--logdest LOGDEST", "-l") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:logset] = true
     rescue => detail
       $stderr.puts detail.to_s
     end
   end
 
   def run_command
     if options[:catalog]
       apply
     elsif Puppet[:parseonly]
       parseonly
     else
       main
     end
   end
 
   def apply
     if options[:catalog] == "-"
       text = $stdin.read
     else
       text = File.read(options[:catalog])
     end
 
     begin
       catalog = Puppet::Resource::Catalog.convert_from(Puppet::Resource::Catalog.default_format,text)
       catalog = Puppet::Resource::Catalog.pson_create(catalog) unless catalog.is_a?(Puppet::Resource::Catalog)
     rescue => detail
       raise Puppet::Error, "Could not deserialize catalog from pson: #{detail}"
     end
 
     catalog = catalog.to_ral
 
     require 'puppet/configurer'
     configurer = Puppet::Configurer.new
     configurer.run :catalog => catalog
   end
 
   def parseonly
     # Set our code or file to use.
     if options[:code] or command_line.args.length == 0
       Puppet[:code] = options[:code] || STDIN.read
     else
       Puppet[:manifest] = command_line.args.shift
     end
     begin
       Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types
     rescue => detail
       Puppet.err detail
       exit 1
     end
     exit 0
   end
 
   def main
     # Set our code or file to use.
     if options[:code] or command_line.args.length == 0
       Puppet[:code] = options[:code] || STDIN.read
     else
       manifest = command_line.args.shift
       raise "Could not find file #{manifest}" unless File.exist?(manifest)
       Puppet.warning("Only one file can be applied per run.  Skipping #{command_line.args.join(', ')}") if command_line.args.size > 0
       Puppet[:manifest] = manifest
     end
 
     # Collect our facts.
     unless facts = Puppet::Node::Facts.find(Puppet[:certname])
       raise "Could not find facts for #{Puppet[:certname]}"
     end
 
     # Find our Node
     unless node = Puppet::Node.find(Puppet[:certname])
       raise "Could not find node #{Puppet[:certname]}"
     end
 
     # Merge in the facts.
     node.merge(facts.values)
 
     # Allow users to load the classes that puppet agent creates.
     if options[:loadclasses]
       file = Puppet[:classfile]
       if FileTest.exists?(file)
         unless FileTest.readable?(file)
           $stderr.puts "#{file} is not readable"
           exit(63)
         end
         node.classes = File.read(file).split(/[\s\n]+/)
       end
     end
 
     begin
       # Compile our catalog
       starttime = Time.now
       catalog = Puppet::Resource::Catalog.find(node.name, :use_node => node)
 
       # Translate it to a RAL catalog
       catalog = catalog.to_ral
 
       catalog.finalize
 
       catalog.retrieval_duration = Time.now - starttime
 
       require 'puppet/configurer'
       configurer = Puppet::Configurer.new
-      configurer.execute_prerun_command
+      report = configurer.run(:skip_plugin_download => true, :catalog => catalog)
 
-      # And apply it
-      if Puppet[:report]
-        report = configurer.initialize_report
-        Puppet::Util::Log.newdestination(report)
-      end
-      transaction = catalog.apply
-
-      configurer.execute_postrun_command
-
-      if Puppet[:report]
-        Puppet::Util::Log.close(report)
-        configurer.send_report(report, transaction)
-      else
-        transaction.generate_report
-      end
-
-      exit( Puppet[:noop] ? 0 : options[:detailed_exitcodes] ? transaction.report.exit_status : 0 )
+      exit( Puppet[:noop] ? 0 : options[:detailed_exitcodes] ? report.exit_status : 0 )
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       $stderr.puts detail.message
       exit(1)
     end
   end
 
   def setup
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     # If noop is set, then also enable diffs
     Puppet[:show_diff] = true if Puppet[:noop]
 
     Puppet::Util::Log.newdestination(:console) unless options[:logset]
     client = nil
     server = nil
 
     trap(:INT) do
       $stderr.puts "Exiting"
       exit(1)
     end
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
   end
 end
diff --git a/lib/puppet/configurer.rb b/lib/puppet/configurer.rb
index 31d31c2d2..2687f5fbd 100644
--- a/lib/puppet/configurer.rb
+++ b/lib/puppet/configurer.rb
@@ -1,239 +1,239 @@
 # The client for interacting with the puppetmaster config server.
 require 'sync'
 require 'timeout'
 require 'puppet/network/http_pool'
 require 'puppet/util'
 
 class Puppet::Configurer
   class CommandHookError < RuntimeError; end
 
   require 'puppet/configurer/fact_handler'
   require 'puppet/configurer/plugin_handler'
 
   include Puppet::Configurer::FactHandler
   include Puppet::Configurer::PluginHandler
 
   # For benchmarking
   include Puppet::Util
 
   attr_reader :compile_time
 
   # Provide more helpful strings to the logging that the Agent does
   def self.to_s
     "Puppet configuration client"
   end
 
   class << self
     # Puppetd should only have one instance running, and we need a way
     # to retrieve it.
     attr_accessor :instance
     include Puppet::Util
   end
 
   # How to lock instances of this class.
   def self.lockfile_path
     Puppet[:puppetdlockfile]
   end
 
   def clear
     @catalog.clear(true) if @catalog
     @catalog = nil
   end
 
   def execute_postrun_command
     execute_from_setting(:postrun_command)
   end
 
   def execute_prerun_command
     execute_from_setting(:prerun_command)
   end
 
   # Initialize and load storage
   def dostorage
       Puppet::Util::Storage.load
       @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
   rescue => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Corrupt state file #{Puppet[:statefile]}: #{detail}"
       begin
         ::File.unlink(Puppet[:statefile])
         retry
       rescue => detail
         raise Puppet::Error.new("Cannot remove #{Puppet[:statefile]}: #{detail}")
       end
   end
 
   # Just so we can specify that we are "the" instance.
   def initialize
     Puppet.settings.use(:main, :ssl, :agent)
 
     self.class.instance = self
     @running = false
     @splayed = false
   end
 
   def initialize_report
     Puppet::Transaction::Report.new
   end
 
   # Prepare for catalog retrieval.  Downloads everything necessary, etc.
-  def prepare
+  def prepare(options)
     dostorage
 
-    download_plugins
+    download_plugins unless options[:skip_plugin_download]
 
-    download_fact_plugins
+    download_fact_plugins unless options[:skip_plugin_download]
 
     execute_prerun_command
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
   def retrieve_catalog
     if Puppet::Resource::Catalog.indirection.terminus_class == :rest
       # This is a bit complicated.  We need the serialized and escaped facts,
       # and we need to know which format they're encoded in.  Thus, we
       # get a hash with both of these pieces of information.
       fact_options = facts_for_uploading
     else
       fact_options = {}
     end
 
     # First try it with no cache, then with the cache.
     unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(fact_options)) or result = retrieve_new_catalog(fact_options)
       if ! Puppet[:usecacheonfailure]
         Puppet.warning "Not using cache on failed catalog"
         return nil
       end
       result = retrieve_catalog_from_cache(fact_options)
     end
 
     return nil unless result
 
     convert_catalog(result, @duration)
   end
 
   # Convert a plain resource catalog into our full host catalog.
   def convert_catalog(result, duration)
     catalog = result.to_ral
     catalog.finalize
     catalog.retrieval_duration = duration
     catalog.write_class_file
     catalog
   end
 
   # The code that actually runs the catalog.
   # This just passes any options on to the catalog,
   # which accepts :tags and :ignoreschedules.
   def run(options = {})
     begin
-      prepare
+      prepare(options)
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Failed to prepare catalog: #{detail}"
     end
 
     options[:report] ||= initialize_report
     report = options[:report]
     Puppet::Util::Log.newdestination(report)
 
     if catalog = options[:catalog]
       options.delete(:catalog)
     elsif ! catalog = retrieve_catalog
       Puppet.err "Could not retrieve catalog; skipping run"
       return
     end
 
     transaction = nil
 
     begin
       benchmark(:notice, "Finished catalog run") do
         transaction = catalog.apply(options)
       end
       report
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Failed to apply catalog: #{detail}"
       return
     end
   ensure
     # Make sure we forget the retained module_directories of any autoload
     # we might have used.
     Thread.current[:env_module_directories] = nil
 
     # Now close all of our existing http connections, since there's no
     # reason to leave them lying open.
     Puppet::Network::HttpPool.clear_http_instances
     execute_postrun_command
 
     Puppet::Util::Log.close(report)
 
     send_report(report, transaction)
   end
 
   def send_report(report, trans = nil)
     trans.generate_report if trans
     puts report.summary if Puppet[:summarize]
     report.save if Puppet[:report]
   rescue => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err "Could not send report: #{detail}"
   end
 
   private
 
   def self.timeout
     timeout = Puppet[:configtimeout]
     case timeout
     when String
       if timeout =~ /^\d+$/
         timeout = Integer(timeout)
       else
         raise ArgumentError, "Configuration timeout must be an integer"
       end
     when Integer # nothing
     else
       raise ArgumentError, "Configuration timeout must be an integer"
     end
 
     timeout
   end
 
   def execute_from_setting(setting)
     return if (command = Puppet[setting]) == ""
 
     begin
       Puppet::Util.execute([command])
     rescue => detail
       raise CommandHookError, "Could not run command from #{setting}: #{detail}"
     end
   end
 
   def retrieve_catalog_from_cache(fact_options)
     result = nil
     @duration = thinmark do
       result = Puppet::Resource::Catalog.find(Puppet[:certname], fact_options.merge(:ignore_terminus => true))
     end
     Puppet.notice "Using cached catalog"
     result
   rescue => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err "Could not retrieve catalog from cache: #{detail}"
     return nil
   end
 
   def retrieve_new_catalog(fact_options)
     result = nil
     @duration = thinmark do
       result = Puppet::Resource::Catalog.find(Puppet[:certname], fact_options.merge(:ignore_cache => true))
     end
     result
   rescue SystemExit,NoMemoryError
     raise
   rescue Exception => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err "Could not retrieve catalog from remote server: #{detail}"
     return nil
   end
 end
diff --git a/spec/unit/application/apply_spec.rb b/spec/unit/application/apply_spec.rb
index 877c47bcc..4e1744206 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -1,405 +1,405 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/apply'
 require 'puppet/file_bucket/dipper'
+require 'puppet/configurer'
 
 describe Puppet::Application::Apply do
   before :each do
     @apply = Puppet::Application[:apply]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:level=)
   end
 
   [:debug,:loadclasses,:verbose,:use_nodes,:detailed_exitcodes].each do |option|
     it "should declare handle_#{option} method" do
       @apply.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @apply.options.expects(:[]=).with(option, 'arg')
       @apply.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   it "should set the code to the provided code when :execute is used" do
     @apply.options.expects(:[]=).with(:code, 'arg')
     @apply.send("handle_execute".to_sym, 'arg')
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @apply.should_parse_config?.should be_true
   end
 
   describe "when applying options" do
 
     it "should set the log destination with --logdest" do
       Puppet::Log.expects(:newdestination).with("console")
 
       @apply.handle_logdest("console")
     end
 
     it "should put the logset options to true" do
       @apply.options.expects(:[]=).with(:logset,true)
 
       @apply.handle_logdest("console")
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:trap)
       Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       STDIN.stubs(:read)
 
       @apply.options.stubs(:[]).with(any_parameters)
     end
 
     it "should set show_diff on --noop" do
       Puppet.stubs(:[]=)
       Puppet.stubs(:[]).with(:config)
       Puppet.stubs(:[]).with(:noop).returns(true)
 
       Puppet.expects(:[]=).with(:show_diff, true)
 
       @apply.setup
     end
 
     it "should set console as the log destination if logdest option wasn't provided" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @apply.setup
     end
 
     it "should set INT trap" do
       @apply.expects(:trap).with(:INT)
 
       @apply.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @apply.options.stubs(:[]).with(:debug).returns(true)
 
       Puppet::Log.expects(:level=).with(:debug)
 
       @apply.setup
     end
 
     it "should set log level to info if --verbose was passed" do
       @apply.options.stubs(:[]).with(:verbose).returns(true)
 
       Puppet::Log.expects(:level=).with(:info)
 
       @apply.setup
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @apply.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @apply.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @apply.setup }.should raise_error(SystemExit)
     end
 
   end
 
   describe "when executing" do
 
     it "should dispatch to parseonly if parseonly is set" do
       @apply.stubs(:options).returns({})
       Puppet.stubs(:[]).with(:parseonly).returns(true)
 
       @apply.expects(:parseonly)
       @apply.run_command
     end
 
     it "should dispatch to 'apply' if it was called with 'apply'" do
       @apply.options[:catalog] = "foo"
 
       @apply.expects(:apply)
       @apply.run_command
     end
 
     it "should dispatch to main if parseonly is not set" do
       @apply.stubs(:options).returns({})
       Puppet.stubs(:[]).with(:parseonly).returns(false)
 
       @apply.expects(:main)
       @apply.run_command
     end
 
     describe "the parseonly command" do
       before :each do
         Puppet.stubs(:[]).with(:environment)
         Puppet.stubs(:[]).with(:manifest).returns("site.pp")
         Puppet.stubs(:err)
         @apply.stubs(:exit)
         @apply.options.stubs(:[]).with(:code).returns "some code"
         @collection = stub_everything
         Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
       end
 
       it "should use a Puppet Resource Type Collection to parse the file" do
         @collection.expects(:perform_initial_import)
         @apply.parseonly
       end
 
       it "should exit with exit code 0 if no error" do
         @apply.expects(:exit).with(0)
         @apply.parseonly
       end
 
       it "should exit with exit code 1 if error" do
         @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
         @apply.expects(:exit).with(1)
         @apply.parseonly
       end
     end
 
     describe "the main command" do
       before :each do
         Puppet.stubs(:[])
         Puppet.settings.stubs(:use)
         Puppet.stubs(:[]).with(:prerun_command).returns ""
         Puppet.stubs(:[]).with(:postrun_command).returns ""
         Puppet.stubs(:[]).with(:trace).returns(true)
 
         @apply.options.stubs(:[])
 
         @facts = stub_everything 'facts'
         Puppet::Node::Facts.stubs(:find).returns(@facts)
 
         @node = stub_everything 'node'
         Puppet::Node.stubs(:find).returns(@node)
 
         @catalog = stub_everything 'catalog'
         @catalog.stubs(:to_ral).returns(@catalog)
         Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
 
         STDIN.stubs(:read)
 
         @transaction = stub_everything 'transaction'
         @catalog.stubs(:apply).returns(@transaction)
 
         @apply.stubs(:exit)
+
+        Puppet::Util::Storage.stubs(:load)
+        Puppet::Configurer.any_instance.stubs(:save_last_run_summary) # to prevent it from trying to write files
       end
 
       it "should set the code to run from --code" do
         @apply.options.stubs(:[]).with(:code).returns("code to run")
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
       end
 
       it "should set the code to run from STDIN if no arguments" do
         @apply.command_line.stubs(:args).returns([])
         STDIN.stubs(:read).returns("code to run")
 
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
       end
 
       it "should set the manifest if a file is passed on command line and the file exists" do
         File.stubs(:exist?).with('site.pp').returns true
         @apply.command_line.stubs(:args).returns(['site.pp'])
 
         Puppet.expects(:[]=).with(:manifest,"site.pp")
 
         @apply.main
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
         File.stubs(:exist?).with('noexist.pp').returns false
         @apply.command_line.stubs(:args).returns(['noexist.pp'])
         lambda { @apply.main }.should raise_error(RuntimeError, 'Could not find file noexist.pp')
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
         File.stubs(:exist?).with('starwarsIV').returns true
         File.expects(:exist?).with('starwarsI').never
         @apply.command_line.stubs(:args).returns(['starwarsIV', 'starwarsI', 'starwarsII'])
 
         Puppet.expects(:[]=).with(:manifest,"starwarsIV")
         Puppet.expects(:warning).with('Only one file can be applied per run.  Skipping starwarsI, starwarsII')
 
         @apply.main
       end
 
       it "should collect the node facts" do
         Puppet::Node::Facts.expects(:find).returns(@facts)
 
         @apply.main
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node::Facts.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should look for the node" do
         Puppet::Node.expects(:find).returns(@node)
 
         @apply.main
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should merge in our node the loaded facts" do
         @facts.stubs(:values).returns("values")
 
         @node.expects(:merge).with("values")
 
         @apply.main
       end
 
       it "should load custom classes if loadclasses" do
         @apply.options.stubs(:[]).with(:loadclasses).returns(true)
         Puppet.stubs(:[]).with(:classfile).returns("/etc/puppet/classes.txt")
         FileTest.stubs(:exists?).with("/etc/puppet/classes.txt").returns(true)
         FileTest.stubs(:readable?).with("/etc/puppet/classes.txt").returns(true)
         File.stubs(:read).with("/etc/puppet/classes.txt").returns("class")
 
         @node.expects(:classes=)
 
         @apply.main
       end
 
       it "should compile the catalog" do
         Puppet::Resource::Catalog.expects(:find).returns(@catalog)
 
         @apply.main
       end
 
       it "should transform the catalog to ral" do
 
         @catalog.expects(:to_ral).returns(@catalog)
 
         @apply.main
       end
 
       it "should finalize the catalog" do
         @catalog.expects(:finalize)
 
         @apply.main
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
-        configurer = stub 'configurer'
-
-        Puppet::Configurer.expects(:new).returns configurer
-        configurer.expects(:execute_prerun_command)
-        configurer.expects(:execute_postrun_command)
+        Puppet::Configurer.any_instance.expects(:execute_prerun_command)
+        Puppet::Configurer.any_instance.expects(:execute_postrun_command)
 
         @apply.main
       end
 
       it "should apply the catalog" do
         @catalog.expects(:apply).returns(stub_everything('transaction'))
 
         @apply.main
       end
 
       describe "with detailed_exitcodes" do
         it "should exit with report's computed exit status" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
-          report = stub 'report', :exit_status => 666
-          @transaction.stubs(:report).returns(report)
+          Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
           @apply.expects(:exit).with(666)
 
           @apply.main
         end
 
         it "should always exit with 0 if option is disabled" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
 
           @apply.main
         end
 
         it "should always exit with 0 if --noop" do
           Puppet.stubs(:[]).with(:noop).returns(true)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
 
           @apply.main
         end
       end
     end
 
     describe "the 'apply' command" do
       it "should read the catalog in from disk if a file name is provided" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.expects(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should read the catalog in from stdin if '-' is provided" do
         @apply.options[:catalog] = "-"
         $stdin.expects(:read).returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should deserialize the catalog from the default format" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
         Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should fail helpfully if deserializing fails" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something syntacically invalid"
         lambda { @apply.apply }.should raise_error(Puppet::Error)
       end
 
       it "should convert plain data structures into a catalog if deserialization does not do so" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,"something").returns({:foo => "bar"})
         Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
         @apply.apply
       end
 
       it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns catalog
         catalog.expects(:to_ral).returns "mycatalog"
 
         configurer = stub 'configurer'
         Puppet::Configurer.expects(:new).returns configurer
         configurer.expects(:run).with(:catalog => "mycatalog")
 
         @apply.apply
       end
     end
   end
 end
diff --git a/spec/unit/configurer_spec.rb b/spec/unit/configurer_spec.rb
index ebc5768ea..72754f398 100755
--- a/spec/unit/configurer_spec.rb
+++ b/spec/unit/configurer_spec.rb
@@ -1,494 +1,494 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-11-12.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
   end
 
   it "should include the Plugin Handler module" do
     Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::PluginHandler)
   end
 
   it "should include the Fact Handler module" do
     Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::FactHandler)
   end
 
   it "should use the puppetdlockfile as its lockfile path" do
     Puppet.settings.expects(:value).with(:puppetdlockfile).returns("/my/lock")
     Puppet::Configurer.lockfile_path.should == "/my/lock"
   end
 
   describe "when executing a pre-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:prerun_command] = ""
       Puppet::Util.expects(:exec).never
 
       @agent.execute_prerun_command
     end
 
     it "should execute any pre-run command provided via the 'prerun_command' setting" do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util.expects(:execute).with { |args| args[0] == "/my/command" }
 
       @agent.execute_prerun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
 
       lambda { @agent.execute_prerun_command }.should raise_error(Puppet::Configurer::CommandHookError)
     end
   end
 
   describe "when executing a post-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:postrun_command] = ""
       Puppet::Util.expects(:exec).never
 
       @agent.execute_postrun_command
     end
 
     it "should execute any post-run command provided via the 'postrun_command' setting" do
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util.expects(:execute).with { |args| args[0] == "/my/command" }
 
       @agent.execute_postrun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
 
       lambda { @agent.execute_postrun_command }.should raise_error(Puppet::Configurer::CommandHookError)
     end
   end
 end
 
 describe Puppet::Configurer, "when initializing a report" do
   it "should return an instance of a transaction report" do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.initialize_report.should be_instance_of(Puppet::Transaction::Report)
   end
 end
 
 describe Puppet::Configurer, "when executing a catalog run" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:prepare)
     @agent.stubs(:facts_for_uploading).returns({})
     @catalog = Puppet::Resource::Catalog.new
     @catalog.stubs(:apply)
     @agent.stubs(:retrieve_catalog).returns @catalog
 
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:close)
   end
 
   it "should prepare for the run" do
     @agent.expects(:prepare)
 
     @agent.run
   end
 
   it "should initialize a transaction report if one is not provided" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     @agent.run
   end
 
   it "should pass the new report to the catalog" do
     report = stub 'report'
     @agent.stubs(:initialize_report).returns report
     @catalog.expects(:apply).with{|options| options[:report] == report}
 
     @agent.run
   end
 
   it "should use the provided report if it was passed one" do
     report = stub 'report'
     @agent.expects(:initialize_report).never
     @catalog.expects(:apply).with{|options| options[:report] == report}
 
     @agent.run(:report => report)
   end
 
   it "should set the report as a log destination" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     Puppet::Util::Log.expects(:newdestination).with(report)
 
     @agent.run
   end
 
   it "should retrieve the catalog" do
     @agent.expects(:retrieve_catalog)
 
     @agent.run
   end
 
   it "should log a failure and do nothing if no catalog can be retrieved" do
     @agent.expects(:retrieve_catalog).returns nil
 
     Puppet.expects(:err).with "Could not retrieve catalog; skipping run"
 
     @agent.run
   end
 
   it "should apply the catalog with all options to :run" do
     @agent.expects(:retrieve_catalog).returns @catalog
 
     @catalog.expects(:apply).with { |args| args[:one] == true }
     @agent.run :one => true
   end
 
   it "should accept a catalog and use it instead of retrieving a different one" do
     @agent.expects(:retrieve_catalog).never
 
     @catalog.expects(:apply)
     @agent.run :one => true, :catalog => @catalog
   end
 
   it "should benchmark how long it takes to apply the catalog" do
     @agent.expects(:benchmark).with(:notice, "Finished catalog run")
 
     @agent.expects(:retrieve_catalog).returns @catalog
 
     @catalog.expects(:apply).never # because we're not yielding
     @agent.run
   end
 
   it "should execute post-run hooks after the run" do
     @agent.expects(:execute_postrun_command)
 
     @agent.run
   end
 
   it "should send the report" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
     @agent.expects(:send_report).with { |r, trans| r == report }
 
     @agent.run
   end
 
   it "should send the transaction report with a reference to the transaction if a run was actually made" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     trans = stub 'transaction'
     @catalog.expects(:apply).returns trans
 
     @agent.expects(:send_report).with { |r, t| t == trans }
 
     @agent.run :catalog => @catalog
   end
 
   it "should send the transaction report even if the catalog could not be retrieved" do
     @agent.expects(:retrieve_catalog).returns nil
 
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
     @agent.expects(:send_report)
 
     @agent.run
   end
 
   it "should send the transaction report even if there is a failure" do
     @agent.expects(:retrieve_catalog).raises "whatever"
 
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
     @agent.expects(:send_report)
 
     lambda { @agent.run }.should raise_error
   end
 
   it "should remove the report as a log destination when the run is finished" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     Puppet::Util::Log.expects(:close).with(report)
 
     @agent.run
   end
 
   it "should return the report as the result of the run" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     @agent.run.should equal(report)
   end
 end
 
 describe Puppet::Configurer, "when sending a report" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @configurer = Puppet::Configurer.new
 
     @report = stub 'report'
     @trans = stub 'transaction'
   end
 
   it "should require a report" do
     lambda { @configurer.send_report }.should raise_error(ArgumentError)
   end
 
   it "should allow specification of a transaction" do
     lambda { @configurer.send_report(@report, @trans)  }.should_not raise_error(ArgumentError)
   end
 
   it "should use any provided transaction to add metrics to the report" do
     @trans.expects(:generate_report)
     @configurer.send_report(@report, @trans)
   end
 
   it "should print a report summary if configured to do so" do
     Puppet.settings[:summarize] = true
 
     @report.expects(:summary).returns "stuff"
 
     @configurer.expects(:puts).with("stuff")
     @configurer.send_report(@report)
   end
 
   it "should not print a report summary if not configured to do so" do
     Puppet.settings[:summarize] = false
 
     @configurer.expects(:puts).never
     @configurer.send_report(@report)
   end
 
   it "should save the report if reporting is enabled" do
     Puppet.settings[:report] = true
 
     @report.expects(:save)
     @configurer.send_report(@report)
   end
 
   it "should not save the report if reporting is disabled" do
     Puppet.settings[:report] = false
 
     @report.expects(:save).never
     @configurer.send_report(@report)
   end
 
   it "should log but not fail if saving the report fails" do
     Puppet.settings[:report] = true
 
     @report.expects(:save).raises "whatever"
 
     Puppet.expects(:err)
     lambda { @configurer.send_report(@report) }.should_not raise_error
   end
 end
 
 describe Puppet::Configurer, "when retrieving a catalog" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:facts_for_uploading).returns({})
 
     @catalog = Puppet::Resource::Catalog.new
 
     # this is the default when using a Configurer instance
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
 
     @agent.stubs(:convert_catalog).returns @catalog
   end
 
   describe "and configured to only retrieve a catalog from the cache" do
     before do
       Puppet.settings[:use_cached_catalog] = true
     end
 
     it "should first look in the cache for a catalog" do
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
 
       @agent.retrieve_catalog.should == @catalog
     end
 
     it "should compile a new catalog if none is found in the cache" do
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
       @agent.retrieve_catalog.should == @catalog
     end
   end
 
   describe "when not using a REST terminus for catalogs" do
     it "should not pass any facts when retrieving the catalog" do
       @agent.expects(:facts_for_uploading).never
       Puppet::Resource::Catalog.expects(:find).with { |name, options|
         options[:facts].nil?
       }.returns @catalog
 
       @agent.retrieve_catalog
     end
   end
 
   describe "when using a REST terminus for catalogs" do
     it "should pass the prepared facts and the facts format as arguments when retrieving the catalog" do
       @agent.expects(:facts_for_uploading).returns(:facts => "myfacts", :facts_format => :foo)
       Puppet::Resource::Catalog.expects(:find).with { |name, options|
         options[:facts] == "myfacts" and options[:facts_format] == :foo
       }.returns @catalog
 
       @agent.retrieve_catalog
     end
   end
 
   it "should use the Catalog class to get its catalog" do
     Puppet::Resource::Catalog.expects(:find).returns @catalog
 
     @agent.retrieve_catalog
   end
 
   it "should use its certname to retrieve the catalog" do
     Facter.stubs(:value).returns "eh"
     Puppet.settings[:certname] = "myhost.domain.com"
     Puppet::Resource::Catalog.expects(:find).with { |name, options| name == "myhost.domain.com" }.returns @catalog
 
     @agent.retrieve_catalog
   end
 
   it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should log and return the cached catalog when no catalog can be retrieved from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
     Puppet.expects(:notice)
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should not look in the cache for a catalog if one is returned from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should return the cached catalog when retrieving the remote catalog throws an exception" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
     Puppet.stubs(:[])
     Puppet.expects(:[]).with(:usecacheonfailure).returns false
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
 
     Puppet.expects(:warning)
 
     @agent.retrieve_catalog.should be_nil
   end
 
   it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
 
     @agent.retrieve_catalog.should be_nil
   end
 
   it "should convert the catalog before returning" do
     Puppet::Resource::Catalog.stubs(:find).returns @catalog
 
     @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
     @agent.retrieve_catalog.should == "converted catalog"
   end
 
   it "should return nil if there is an error while retrieving the catalog" do
     Puppet::Resource::Catalog.expects(:find).at_least_once.raises "eh"
 
     @agent.retrieve_catalog.should be_nil
   end
 end
 
 describe Puppet::Configurer, "when converting the catalog" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
 
     @catalog = Puppet::Resource::Catalog.new
     @oldcatalog = stub 'old_catalog', :to_ral => @catalog
   end
 
   it "should convert the catalog to a RAL-formed catalog" do
     @oldcatalog.expects(:to_ral).returns @catalog
 
     @agent.convert_catalog(@oldcatalog, 10).should equal(@catalog)
   end
 
   it "should finalize the catalog" do
     @catalog.expects(:finalize)
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 
   it "should record the passed retrieval time with the RAL catalog" do
     @catalog.expects(:retrieval_duration=).with 10
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 
   it "should write the RAL catalog's class file" do
     @catalog.expects(:write_class_file)
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 end
 
 describe Puppet::Configurer, "when preparing for a run" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:dostorage)
     @agent.stubs(:download_fact_plugins)
     @agent.stubs(:download_plugins)
     @agent.stubs(:execute_prerun_command)
     @facts = {"one" => "two", "three" => "four"}
   end
 
   it "should initialize the metadata store" do
     @agent.class.stubs(:facts).returns(@facts)
     @agent.expects(:dostorage)
-    @agent.prepare
+    @agent.prepare({})
   end
 
   it "should download fact plugins" do
     @agent.expects(:download_fact_plugins)
 
-    @agent.prepare
+    @agent.prepare({})
   end
 
   it "should download plugins" do
     @agent.expects(:download_plugins)
 
-    @agent.prepare
+    @agent.prepare({})
   end
 
   it "should perform the pre-run commands" do
     @agent.expects(:execute_prerun_command)
-    @agent.prepare
+    @agent.prepare({})
   end
 end