puppet 2.6.18 → 2.7.1

data/spec/unit/configurer/downloader_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/configurer/downloader'
 

data/spec/unit/configurer/fact_handler_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 require 'puppet/configurer'
 require 'puppet/configurer/fact_handler'
 
@@ -13,6 +12,14 @@ describe Puppet::Configurer::FactHandler do
     @facthandler = FactHandlerTester.new
   end
 
+  it "should have a method for downloading fact plugins" do
+    @facthandler.should respond_to(:download_fact_plugins)
+  end
+
+  it "should have a boolean method for determining whether fact plugins should be downloaded" do
+    @facthandler.should respond_to(:download_fact_plugins?)
+  end
+
   it "should download fact plugins when :factsync is true" do
     Puppet.settings.expects(:value).with(:factsync).returns true
     @facthandler.should be_download_fact_plugins
@@ -44,60 +51,46 @@ describe Puppet::Configurer::FactHandler do
     @facthandler.download_fact_plugins
   end
 
-  describe "when finding facts" do
-    before :each do
-      @facthandler.stubs(:reload_facter)
-      Puppet::Node::Facts.terminus_class = :memory
-    end
-
-    it "should use the node name value to retrieve the facts" do
-      foo_facts = Puppet::Node::Facts.new('foo')
-      bar_facts = Puppet::Node::Facts.new('bar')
-      foo_facts.save
-      bar_facts.save
-      Puppet[:certname] = 'foo'
-      Puppet[:node_name_value] = 'bar'
-
-      @facthandler.find_facts.should == bar_facts
-    end
+  it "should warn about factsync deprecation when factsync is enabled" do
+    Puppet::Configurer::Downloader.stubs(:new).returns mock("downloader", :evaluate => nil)
 
-    it "should set the facts name based on the node_name_fact" do
-      Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name').save
-      Puppet[:node_name_fact] = 'my_name_fact'
+    @facthandler.expects(:download_fact_plugins?).returns true
+    Puppet.expects(:warning)
+    @facthandler.download_fact_plugins
+  end
 
-      @facthandler.find_facts.name.should == 'other_node_name'
-    end
+  it "should have a method for retrieving facts" do
+    @facthandler.should respond_to(:find_facts)
+  end
 
-    it "should set the node_name_value based on the node_name_fact" do
-      Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name').save
-      Puppet[:node_name_fact] = 'my_name_fact'
+  it "should use the Facts class with the :certname to find the facts" do
+    Puppet.settings.expects(:value).with(:certname).returns "foo"
+    Puppet::Node::Facts.indirection.expects(:find).with("foo").returns "myfacts"
+    @facthandler.stubs(:reload_facter)
+    @facthandler.find_facts.should == "myfacts"
+  end
 
-      @facthandler.find_facts
+  it "should reload Facter and find local facts when asked to find facts" do
+    @facthandler.expects(:reload_facter)
 
-      Puppet[:node_name_value].should == 'other_node_name'
-    end
+    Puppet.settings.expects(:value).with(:certname).returns "myhost"
+    Puppet::Node::Facts.indirection.expects(:find).with("myhost")
 
-    it "should reload Facter before finding facts" do
-      @facthandler.expects(:reload_facter)
+    @facthandler.find_facts
+  end
 
-      @facthandler.find_facts
-    end
+  it "should fail if finding facts fails" do
+    @facthandler.stubs(:reload_facter)
 
-    it "should fail if finding facts fails" do
-      Puppet[:trace] = false
-      Puppet[:certname] = "myhost"
-      Puppet::Node::Facts.expects(:find).raises RuntimeError
+    Puppet.settings.stubs(:value).with(:trace).returns false
+    Puppet.settings.stubs(:value).with(:certname).returns "myhost"
+    Puppet::Node::Facts.indirection.expects(:find).raises RuntimeError
 
-      lambda { @facthandler.find_facts }.should raise_error(Puppet::Error)
-    end
+    lambda { @facthandler.find_facts }.should raise_error(Puppet::Error)
   end
 
-  it "should warn about factsync deprecation when factsync is enabled" do
-    Puppet::Configurer::Downloader.stubs(:new).returns mock("downloader", :evaluate => nil)
-
-    @facthandler.expects(:download_fact_plugins?).returns true
-    Puppet.expects(:warning)
-    @facthandler.download_fact_plugins
+  it "should have a method to prepare the facts for uploading" do
+    @facthandler.should respond_to(:facts_for_uploading)
   end
 
   # I couldn't get marshal to work for this, only yaml, so we hard-code yaml.

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 require 'puppet/configurer'
 require 'puppet/configurer/plugin_handler'
 

data/spec/unit/configurer_spec.rb

@@ -1,16 +1,15 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env rspec
 #
 #  Created by Luke Kanies on 2007-11-12.
 #  Copyright (c) 2007. All rights reserved.
 
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
-    Puppet::Util::Storage.stubs(:store)
   end
 
   it "should include the Plugin Handler module" do
@@ -36,16 +35,16 @@ describe Puppet::Configurer do
 
     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(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      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).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
 
-      @agent.execute_prerun_command.should be_false
+      lambda { @agent.execute_prerun_command }.should raise_error(Puppet::Configurer::CommandHookError)
     end
   end
 
@@ -59,550 +58,469 @@ describe Puppet::Configurer do
 
     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(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      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).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
 
-      @agent.execute_postrun_command.should be_false
+      lambda { @agent.execute_postrun_command }.should raise_error(Puppet::Configurer::CommandHookError)
     end
   end
+end
 
-  describe "when executing a catalog run" do
-    before do
-      Puppet.settings.stubs(:use).returns(true)
-      @agent.stubs(:prepare)
-      Puppet::Node::Facts.terminus_class = :memory
-      @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
-      @facts.save
-
-      @catalog = Puppet::Resource::Catalog.new
-      @catalog.stubs(:to_ral).returns(@catalog)
-      Puppet::Resource::Catalog.terminus_class = :rest
-      Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
-      @agent.stubs(:send_report)
-      @agent.stubs(:save_last_run_summary)
-
-      Puppet::Util::Log.stubs(:close)
-    end
-
-    after :all do
-      Puppet::Node::Facts.indirection.reset_terminus_class
-      Puppet::Resource::Catalog.indirection.reset_terminus_class
-    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 = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns report
-
-      @agent.run
-    end
-
-    it "should respect node_name_fact when setting the host on a report" do
-      Puppet[:node_name_fact] = 'my_name_fact'
-      @facts.values = {'my_name_fact' => 'node_name_from_fact'}
-
-      @agent.run.host.should == 'node_name_from_fact'
-    end
-
-    it "should pass the new report to the catalog" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.stubs(:new).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 = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).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 = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns report
+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
+    @agent.stubs(:save_last_run_summary)
+    Puppet::Transaction::Report.indirection.stubs(:save)
+  end
 
-      Puppet::Util::Log.expects(:newdestination).with(report)
-      Puppet::Util::Log.expects(:close).with(report)
-      Puppet::Util::Log.expects(:close).with([])
+  it "should prepare for the run" do
+    @agent.expects(:prepare)
 
-      @agent.run
-    end
+    @agent.run
+  end
 
-    it "should retrieve the catalog" do
-      @agent.expects(:retrieve_catalog)
+  it "should initialize a transaction report if one is not provided" do
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).at_least_once.returns report
 
-      @agent.run
-    end
+    @agent.run
+  end
 
-    it "should log a failure and do nothing if no catalog can be retrieved" do
-      @agent.expects(:retrieve_catalog).returns nil
+  it "should pass the new report to the catalog" do
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.stubs(:new).returns report
+    @catalog.expects(:apply).with{|options| options[:report] == report}
 
-      Puppet.expects(:err).with "Could not retrieve catalog; skipping run"
+    @agent.run
+  end
 
-      @agent.run
-    end
+  it "should use the provided report if it was passed one" do
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).never
+    @catalog.expects(:apply).with{|options| options[:report] == report}
 
-    it "should apply the catalog with all options to :run" do
-      @agent.expects(:retrieve_catalog).returns @catalog
+    @agent.run(:report => report)
+  end
 
-      @catalog.expects(:apply).with { |args| args[:one] == true }
-      @agent.run :one => true
-    end
+  it "should set the report as a log destination" do
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns report
 
-    it "should accept a catalog and use it instead of retrieving a different one" do
-      @agent.expects(:retrieve_catalog).never
+    @agent.stubs(:send_report)
+    Puppet::Util::Log.expects(:newdestination).with(report)
 
-      @catalog.expects(:apply)
-      @agent.run :one => true, :catalog => @catalog
-    end
+    @agent.run
+  end
 
-    it "should benchmark how long it takes to apply the catalog" do
-      @agent.expects(:benchmark).with(:notice, "Finished catalog run")
+  it "should retrieve the catalog" do
+    @agent.expects(:retrieve_catalog)
 
-      @agent.expects(:retrieve_catalog).returns @catalog
+    @agent.run
+  end
 
-      @catalog.expects(:apply).never # because we're not yielding
-      @agent.run
-    end
+  it "should log a failure and do nothing if no catalog can be retrieved" do
+    @agent.expects(:retrieve_catalog).returns nil
 
-    it "should execute post-run hooks after the run" do
-      @agent.expects(:execute_postrun_command)
+    Puppet.expects(:err).with "Could not retrieve catalog; skipping run"
 
-      @agent.run
-    end
+    @agent.run
+  end
 
-    it "should send the report" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report).with(report)
+  it "should apply the catalog with all options to :run" do
+    @agent.expects(:retrieve_catalog).returns @catalog
 
-      @agent.run
-    end
+    @catalog.expects(:apply).with { |args| args[:one] == true }
+    @agent.run :one => true
+  end
 
-    it "should send the transaction report even if the catalog could not be retrieved" do
-      @agent.expects(:retrieve_catalog).returns nil
+  it "should accept a catalog and use it instead of retrieving a different one" do
+    @agent.expects(:retrieve_catalog).never
 
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report)
+    @catalog.expects(:apply)
+    @agent.run :one => true, :catalog => @catalog
+  end
 
-      @agent.run
-    end
+  it "should benchmark how long it takes to apply the catalog" do
+    @agent.expects(:benchmark).with(:notice, "Finished catalog run")
 
-    it "should send the transaction report even if there is a failure" do
-      @agent.expects(:retrieve_catalog).raises "whatever"
+    @agent.expects(:retrieve_catalog).returns @catalog
 
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report)
+    @catalog.expects(:apply).never # because we're not yielding
+    @agent.run
+  end
 
-      @agent.run.should be_nil
-    end
+  it "should execute post-run hooks after the run" do
+    @agent.expects(:execute_postrun_command)
 
-    it "should remove the report as a log destination when the run is finished" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+    @agent.run
+  end
 
-      Puppet::Util::Log.expects(:close).with(report)
+  it "should send the report" do
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
+    @agent.expects(:send_report).with { |r, trans| r == report }
 
-      @agent.run
-    end
+    @agent.run
+  end
 
-    it "should return the report as the result of the run" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+  it "should send the transaction report with a reference to the transaction if a run was actually made" do
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
 
-      @agent.run.should equal(report)
-    end
+    trans = stub 'transaction'
+    @catalog.expects(:apply).returns trans
 
-    it "should send the transaction report even if the pre-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+    @agent.expects(:send_report).with { |r, t| t == trans }
 
-      Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
-      @agent.expects(:send_report)
+    @agent.run :catalog => @catalog
+  end
 
-      @agent.run.should be_nil
-    end
+  it "should send the transaction report even if the catalog could not be retrieved" do
+    @agent.expects(:retrieve_catalog).returns nil
 
-    it "should include the pre-run command failure in the report" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
+    @agent.expects(:send_report)
 
-      Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+    @agent.run
+  end
 
-      report.expects(:<<).with { |log| log.message.include?("Could not run command from prerun_command") }
+  it "should send the transaction report even if there is a failure" do
+    @agent.expects(:retrieve_catalog).raises "whatever"
 
-      @agent.run.should be_nil
-    end
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
+    @agent.expects(:send_report)
 
-    it "should send the transaction report even if the post-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+    lambda { @agent.run }.should raise_error
+  end
 
-      Puppet.settings[:postrun_command] = "/my/command"
-      Puppet::Util.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
-      @agent.expects(:send_report)
+  it "should remove the report as a log destination when the run is finished" do
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
 
-      @agent.run.should be_nil
-    end
+    report.expects(:<<).at_least_once
 
-    it "should include the post-run command failure in the report" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+    @agent.run
+    Puppet::Util::Log.destinations.should_not include(report)
+  end
 
-      Puppet.settings[:postrun_command] = "/my/command"
-      Puppet::Util.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+  it "should return the report as the result of the run" do
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
 
-      report.expects(:<<).with { |log| log.message.include?("Could not run command from postrun_command") }
+    @agent.run.should equal(report)
+  end
+end
 
-      @agent.run.should be_nil
-    end
+describe Puppet::Configurer, "when sending a report" do
+  include PuppetSpec::Files
 
-    it "should execute post-run command even if the pre-run command fails" do
-      Puppet.settings[:prerun_command] = "/my/precommand"
-      Puppet.settings[:postrun_command] = "/my/postcommand"
-      Puppet::Util.expects(:execute).with(["/my/precommand"]).raises(Puppet::ExecutionFailure, "Failed")
-      Puppet::Util.expects(:execute).with(["/my/postcommand"])
+  before do
+    Puppet.settings.stubs(:use).returns(true)
+    @configurer = Puppet::Configurer.new
+    Puppet[:lastrunfile] = tmpfile('last_run_file')
 
-      @agent.run.should be_nil
-    end
+    @report = Puppet::Transaction::Report.new("apply")
+    @trans = stub 'transaction'
+  end
 
-    it "should finalize the report" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+  it "should finalize the report" do
+    @report.expects(:finalize_report)
+    @configurer.send_report(@report, @trans)
+  end
 
-      report.expects(:finalize_report)
-      @agent.run
-    end
+  it "should print a report summary if configured to do so" do
+    Puppet.settings[:summarize] = true
 
-    it "should not apply the catalog if the pre-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+    @report.expects(:summary).returns "stuff"
 
-      Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+    @configurer.expects(:puts).with("stuff")
+    @configurer.send_report(@report, nil)
+  end
 
-      @catalog.expects(:apply).never()
-      @agent.expects(:send_report)
+  it "should not print a report summary if not configured to do so" do
+    Puppet.settings[:summarize] = false
 
-      @agent.run.should be_nil
-    end
+    @configurer.expects(:puts).never
+    @configurer.send_report(@report, nil)
+  end
 
-    it "should apply the catalog, send the report, and return nil if the post-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns(report)
+  it "should save the report if reporting is enabled" do
+    Puppet.settings[:report] = true
 
-      Puppet.settings[:postrun_command] = "/my/command"
-      Puppet::Util.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+    Puppet::Transaction::Report.indirection.expects(:save).with(@report)
+    @configurer.send_report(@report, nil)
+  end
 
-      @catalog.expects(:apply)
-      @agent.expects(:send_report)
+  it "should not save the report if reporting is disabled" do
+    Puppet.settings[:report] = false
 
-      @agent.run.should be_nil
-    end
+    Puppet::Transaction::Report.indirection.expects(:save).never
+    @configurer.send_report(@report, nil)
+  end
 
-    describe "when not using a REST terminus for catalogs" do
-      it "should not pass any facts when retrieving the catalog" do
-        Puppet::Resource::Catalog.terminus_class = :compiler
-        @agent.expects(:facts_for_uploading).never
-        Puppet::Resource::Catalog.expects(:find).with { |name, options|
-          options[:facts].nil?
-        }.returns @catalog
+  it "should save the last run summary if reporting is enabled" do
+    Puppet.settings[:report] = true
 
-        @agent.run
-      end
-    end
+    @configurer.expects(:save_last_run_summary).with(@report)
+    @configurer.send_report(@report, nil)
+  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
-        Puppet::Resource::Catalog.terminus_class = :rest
-        @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
+  it "should save the last run summary if reporting is disabled" do
+    Puppet.settings[:report] = false
 
-        @agent.run
-      end
-    end
+    @configurer.expects(:save_last_run_summary).with(@report)
+    @configurer.send_report(@report, nil)
   end
 
-  describe "when sending a report" do
-    include PuppetSpec::Files
+  it "should log but not fail if saving the report fails" do
+    Puppet.settings[:report] = true
 
-    before do
-      Puppet.settings.stubs(:use).returns(true)
-      @configurer = Puppet::Configurer.new
-      Puppet[:lastrunfile] = tmpfile('last_run_file')
+    Puppet::Transaction::Report.indirection.expects(:save).with(@report).raises "whatever"
 
-      @report = Puppet::Transaction::Report.new("apply")
-    end
+    Puppet.expects(:err)
+    lambda { @configurer.send_report(@report, nil) }.should_not raise_error
+  end
+end
 
-    it "should print a report summary if configured to do so" do
-      Puppet.settings[:summarize] = true
+describe Puppet::Configurer, "when saving the summary report file" do
+  before do
+    Puppet.settings.stubs(:use).returns(true)
+    @configurer = Puppet::Configurer.new
 
-      @report.expects(:summary).returns "stuff"
+    @report = stub 'report'
+    @trans = stub 'transaction'
+    @lastrunfd = stub 'lastrunfd'
+    Puppet::Util::FileLocking.stubs(:writelock).yields(@lastrunfd)
+  end
 
-      @configurer.expects(:puts).with("stuff")
-      @configurer.send_report(@report)
-    end
+  it "should write the raw summary to the lastrunfile setting value" do
+    Puppet::Util::FileLocking.expects(:writelock).with(Puppet[:lastrunfile], 0660)
+    @configurer.save_last_run_summary(@report)
+  end
 
-    it "should not print a report summary if not configured to do so" do
-      Puppet.settings[:summarize] = false
+  it "should write the raw summary as yaml" do
+    @report.expects(:raw_summary).returns("summary")
+    @lastrunfd.expects(:print).with(YAML.dump("summary"))
+    @configurer.save_last_run_summary(@report)
+  end
 
-      @configurer.expects(:puts).never
-      @configurer.send_report(@report)
-    end
+  it "should log but not fail if saving the last run summary fails" do
+    Puppet::Util::FileLocking.expects(:writelock).raises "exception"
+    Puppet.expects(:err)
+    lambda { @configurer.save_last_run_summary(@report) }.should_not raise_error
+  end
 
-    it "should save the report if reporting is enabled" do
-      Puppet.settings[:report] = true
+end
 
-      @report.expects(:save)
-      @configurer.send_report(@report)
-    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({})
 
-    it "should not save the report if reporting is disabled" do
-      Puppet.settings[:report] = false
+    @catalog = Puppet::Resource::Catalog.new
 
-      @report.expects(:save).never
-      @configurer.send_report(@report)
-    end
+    # this is the default when using a Configurer instance
+    Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
 
-    it "should save the last run summary if reporting is enabled" do
-      Puppet.settings[:report] = true
+    @agent.stubs(:convert_catalog).returns @catalog
+  end
 
-      @configurer.expects(:save_last_run_summary).with(@report)
-      @configurer.send_report(@report)
+  describe "and configured to only retrieve a catalog from the cache" do
+    before do
+      Puppet.settings[:use_cached_catalog] = true
     end
 
-    it "should save the last run summary if reporting is disabled" do
-      Puppet.settings[:report] = false
+    it "should first look in the cache for a catalog" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
 
-      @configurer.expects(:save_last_run_summary).with(@report)
-      @configurer.send_report(@report)
+      @agent.retrieve_catalog.should == @catalog
     end
 
-    it "should log but not fail if saving the report fails" do
-      Puppet.settings[:report] = true
-
-      @report.expects(:save).raises "whatever"
+    it "should compile a new catalog if none is found in the cache" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
-      Puppet.expects(:err)
-      lambda { @configurer.send_report(@report) }.should_not raise_error
+      @agent.retrieve_catalog.should == @catalog
     end
   end
 
-  describe "when saving the summary report file" do
-    before do
-      Puppet.settings.stubs(:use).returns(true)
-      @configurer = Puppet::Configurer.new
+  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.indirection.expects(:find).with { |name, options|
+        options[:facts].nil?
+      }.returns @catalog
 
-      @report = stub 'report'
-      @trans = stub 'transaction'
-      @lastrunfd = stub 'lastrunfd'
-      Puppet::Util::FileLocking.stubs(:writelock).yields(@lastrunfd)
+      @agent.retrieve_catalog
     end
-
-    it "should write the raw summary to the lastrunfile setting value" do
-      Puppet::Util::FileLocking.expects(:writelock).with(Puppet[:lastrunfile], 0660)
-      @configurer.save_last_run_summary(@report)
-    end
-
-    it "should write the raw summary as yaml" do
-      @report.expects(:raw_summary).returns("summary")
-      @lastrunfd.expects(:print).with(YAML.dump("summary"))
-      @configurer.save_last_run_summary(@report)
-    end
-
-    it "should log but not fail if saving the last run summary fails" do
-      Puppet::Util::FileLocking.expects(:writelock).raises "exception"
-      Puppet.expects(:err)
-      lambda { @configurer.save_last_run_summary(@report) }.should_not raise_error
-    end
-
   end
 
-  describe "when retrieving a catalog" do
-    before do
-      Puppet.settings.stubs(:use).returns(true)
-      @agent.stubs(:facts_for_uploading).returns({})
-
-      @catalog = Puppet::Resource::Catalog.new
+  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.indirection.expects(:find).with { |name, options|
+        options[:facts] == "myfacts" and options[:facts_format] == :foo
+      }.returns @catalog
 
-      # this is the default when using a Configurer instance
-      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
-
-      @agent.stubs(:convert_catalog).returns @catalog
+      @agent.retrieve_catalog
     end
+  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
+  it "should use the Catalog class to get its catalog" do
+    Puppet::Resource::Catalog.indirection.expects(:find).returns @catalog
 
-        @agent.retrieve_catalog({}).should == @catalog
-      end
-    end
+    @agent.retrieve_catalog
+  end
 
-    it "should use the Catalog class to get its catalog" do
-      Puppet::Resource::Catalog.expects(:find).returns @catalog
+  it "should use its certname to retrieve the catalog" do
+    Facter.stubs(:value).returns "eh"
+    Puppet.settings[:certname] = "myhost.domain.com"
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| name == "myhost.domain.com" }.returns @catalog
 
-      @agent.retrieve_catalog({})
-    end
+    @agent.retrieve_catalog
+  end
 
-    it "should use its node_name_value to retrieve the catalog" do
-      Facter.stubs(:value).returns "eh"
-      Puppet.settings[:node_name_value] = "myhost.domain.com"
-      Puppet::Resource::Catalog.expects(:find).with { |name, options| name == "myhost.domain.com" }.returns @catalog
+  it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
-      @agent.retrieve_catalog({})
-    end
+    @agent.retrieve_catalog.should == @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
+  it "should log and return the cached catalog when no catalog can be retrieved from the server" do
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
-      @agent.retrieve_catalog({}).should == @catalog
-    end
+    Puppet.expects(:notice)
 
-    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
+    @agent.retrieve_catalog.should == @catalog
+  end
 
-      Puppet.expects(:notice)
+  it "should not look in the cache for a catalog if one is returned from the server" do
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
 
-      @agent.retrieve_catalog({}).should == @catalog
-    end
+    @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
+  it "should return the cached catalog when retrieving the remote catalog throws an exception" do
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
-      @agent.retrieve_catalog({}).should == @catalog
-    end
+    @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
+  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.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
 
-      @agent.retrieve_catalog({}).should == @catalog
-    end
+    Puppet.expects(:warning)
 
-    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
+    @agent.retrieve_catalog.should be_nil
+  end
 
-      Puppet.expects(:warning)
+  it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
 
-      @agent.retrieve_catalog({}).should be_nil
-    end
+    @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
+  it "should convert the catalog before returning" do
+    Puppet::Resource::Catalog.indirection.stubs(:find).returns @catalog
 
-      @agent.retrieve_catalog({}).should be_nil
-    end
+    @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
+    @agent.retrieve_catalog.should == "converted catalog"
+  end
 
-    it "should convert the catalog before returning" do
-      Puppet::Resource::Catalog.stubs(:find).returns @catalog
+  it "should return nil if there is an error while retrieving the catalog" do
+    Puppet::Resource::Catalog.indirection.expects(:find).at_least_once.raises "eh"
 
-      @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
-      @agent.retrieve_catalog({}).should == "converted catalog"
-    end
+    @agent.retrieve_catalog.should be_nil
+  end
+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"
+describe Puppet::Configurer, "when converting the catalog" do
+  before do
+    Puppet.settings.stubs(:use).returns(true)
+    @agent = Puppet::Configurer.new
 
-      @agent.retrieve_catalog({}).should be_nil
-    end
+    @catalog = Puppet::Resource::Catalog.new
+    @oldcatalog = stub 'old_catalog', :to_ral => @catalog
   end
 
-  describe "when converting the catalog" do
-    before do
-      Puppet.settings.stubs(:use).returns(true)
-
-      @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
 
-    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
 
-      @agent.convert_catalog(@oldcatalog, 10).should equal(@catalog)
-    end
+  it "should finalize the catalog" do
+    @catalog.expects(:finalize)
 
-    it "should finalize the catalog" do
-      @catalog.expects(:finalize)
+    @agent.convert_catalog(@oldcatalog, 10)
+  end
 
-      @agent.convert_catalog(@oldcatalog, 10)
-    end
+  it "should record the passed retrieval time with the RAL catalog" do
+    @catalog.expects(:retrieval_duration=).with 10
 
-    it "should record the passed retrieval time with the RAL catalog" do
-      @catalog.expects(:retrieval_duration=).with 10
+    @agent.convert_catalog(@oldcatalog, 10)
+  end
 
-      @agent.convert_catalog(@oldcatalog, 10)
-    end
+  it "should write the RAL catalog's class file" do
+    @catalog.expects(:write_class_file)
 
-    it "should write the RAL catalog's class file" do
-      @catalog.expects(:write_class_file)
+    @agent.convert_catalog(@oldcatalog, 10)
+  end
+end
 
-      @agent.convert_catalog(@oldcatalog, 10)
-    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
 
-  describe "when preparing for a run" do
-    before do
-      Puppet.settings.stubs(:use).returns(true)
-      @agent.stubs(:dostorage)
-      @agent.stubs(:download_fact_plugins)
-      @agent.stubs(:download_plugins)
-      @facts = {"one" => "two", "three" => "four"}
-    end
+  it "should initialize the metadata store" do
+    @agent.class.stubs(:facts).returns(@facts)
+    @agent.expects(:dostorage)
+    @agent.prepare({})
+  end
 
-    it "should initialize the metadata store" do
-      @agent.class.stubs(:facts).returns(@facts)
-      @agent.expects(:dostorage)
-      @agent.prepare({})
-    end
+  it "should download fact plugins" do
+    @agent.expects(:download_fact_plugins)
 
-    it "should download fact plugins" do
-      @agent.expects(:download_fact_plugins)
+    @agent.prepare({})
+  end
 
-      @agent.prepare({})
-    end
+  it "should download plugins" do
+    @agent.expects(:download_plugins)
 
-    it "should download plugins" do
-      @agent.expects(:download_plugins)
+    @agent.prepare({})
+  end
 
-      @agent.prepare({})
-    end
+  it "should perform the pre-run commands" do
+    @agent.expects(:execute_prerun_command)
+    @agent.prepare({})
   end
 end