diff --git a/lib/puppet.rb b/lib/puppet.rb
index 2e0066ca1..b5c480636 100644
--- a/lib/puppet.rb
+++ b/lib/puppet.rb
@@ -1,175 +1,175 @@
 # Try to load rubygems.  Hey rubygems, I hate you.
 begin
     require 'rubygems'
 rescue LoadError
 end
 
 # see the bottom of the file for further inclusions
 require 'singleton'
 require 'facter'
 require 'puppet/error'
 require 'puppet/util'
 require 'puppet/util/autoload'
 require 'puppet/util/settings'
 require 'puppet/util/feature'
 require 'puppet/util/suidmanager'
+require 'puppet/util/run_mode'
 
 #------------------------------------------------------------
 # the top-level module
 #
 # all this really does is dictate how the whole system behaves, through
 # preferences for things like debugging
 #
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
     PUPPETVERSION = '2.6.0'
 
     def Puppet.version
         return PUPPETVERSION
     end
 
     class << self
         include Puppet::Util
         attr_reader :features
         attr_writer :name
     end
 
     # the hash that determines how our system behaves
     @@settings = Puppet::Util::Settings.new
 
     # The services running in this process.
     @services ||= []
 
     require 'puppet/util/logging'
 
     extend Puppet::Util::Logging
 
     # The feature collection
     @features = Puppet::Util::Feature.new('puppet/feature')
 
     # Load the base features.
     require 'puppet/feature/base'
 
     # Store a new default value.
     def self.setdefaults(section, hash)
         @@settings.setdefaults(section, hash)
     end
 
     # configuration parameter access and stuff
     def self.[](param)
         case param
         when :debug
             if Puppet::Util::Log.level == :debug
                 return true
             else
                 return false
             end
         else
             return @@settings[param]
         end
     end
 
     # configuration parameter access and stuff
     def self.[]=(param,value)
         @@settings[param] = value
     end
 
     def self.clear
         @@settings.clear
     end
 
     def self.debug=(value)
         if value
             Puppet::Util::Log.level=(:debug)
         else
             Puppet::Util::Log.level=(:notice)
         end
     end
 
     def self.settings
         @@settings
     end
 
     def self.run_mode
-        require 'puppet/util/run_mode'
         $puppet_application_mode || Puppet::Util::RunMode[:user]
     end
 
     def self.application_name
         $puppet_application_name ||= "apply"
     end
 
     # Load all of the configuration parameters.
     require 'puppet/defaults'
 
     def self.genmanifest
         if Puppet[:genmanifest]
             puts Puppet.settings.to_manifest
             exit(0)
         end
     end
 
     # Parse the config file for this process.
     def self.parse_config
         Puppet.settings.parse
     end
 
     # XXX this should all be done using puppet objects, not using
     # normal mkdir
     def self.recmkdir(dir,mode = 0755)
         if FileTest.exist?(dir)
             return false
         else
             tmp = dir.sub(/^\//,'')
             path = [File::SEPARATOR]
             tmp.split(File::SEPARATOR).each { |dir|
                 path.push dir
                 if ! FileTest.exist?(File.join(path))
                     begin
                         Dir.mkdir(File.join(path), mode)
                     rescue Errno::EACCES => detail
                         Puppet.err detail.to_s
                         return false
                     rescue => detail
                         Puppet.err "Could not create %s: %s" % [path, detail.to_s]
                         return false
                     end
                 elsif FileTest.directory?(File.join(path))
                     next
                 else FileTest.exist?(File.join(path))
                     raise Puppet::Error, "Cannot create %s: basedir %s is a file" %
                         [dir, File.join(path)]
                 end
             }
             return true
         end
     end
 
     # Create a new type.  Just proxy to the Type class.
     def self.newtype(name, options = {}, &block)
         Puppet::Type.newtype(name, options, &block)
     end
 
     # Retrieve a type by name.  Just proxy to the Type class.
     def self.type(name)
         # LAK:DEP Deprecation notice added 12/17/2008
         Puppet.warning "Puppet.type is deprecated; use Puppet::Type.type"
         Puppet::Type.type(name)
     end
 end
 
 require 'puppet/type'
 require 'puppet/parser'
 require 'puppet/resource'
 require 'puppet/network'
 require 'puppet/ssl'
 require 'puppet/module'
 require 'puppet/util/storage'
 require 'puppet/status'
 require 'puppet/file_bucket/file'
 
 if Puppet[:storeconfigs]
     require 'puppet/rails'
 end
 
diff --git a/lib/puppet/application/cert.rb b/lib/puppet/application/cert.rb
index b368728b8..9625a7ffe 100644
--- a/lib/puppet/application/cert.rb
+++ b/lib/puppet/application/cert.rb
@@ -1,87 +1,87 @@
 require 'puppet/application'
 
 class Puppet::Application::Cert < Puppet::Application
 
     should_parse_config
-    run_mode :server
+    run_mode :master
 
     attr_accessor :cert_mode, :all, :ca, :digest, :signed
 
     def find_mode(opt)
         require 'puppet/ssl/certificate_authority'
         modes = Puppet::SSL::CertificateAuthority::Interface::INTERFACE_METHODS
         tmp = opt.sub("--", '').to_sym
         @cert_mode = modes.include?(tmp) ? tmp : nil
     end
 
     option("--clean", "-c") do
         @cert_mode = :destroy
     end
 
     option("--all", "-a") do
         @all = true
     end
 
     option("--digest DIGEST") do |arg|
         @digest = arg
     end
 
     option("--signed", "-s") do
         @signed = true
     end
 
     option("--debug", "-d") do |arg|
         Puppet::Util::Log.level = :debug
     end
 
     require 'puppet/ssl/certificate_authority/interface'
     Puppet::SSL::CertificateAuthority::Interface::INTERFACE_METHODS.reject {|m| m == :destroy }.each do |method|
         option("--#{method}", "-%s" % method.to_s[0,1] ) do
             find_mode("--#{method}")
         end
     end
 
     option("--verbose", "-v") do
         Puppet::Util::Log.level = :info
     end
 
     def main
         if @all
             hosts = :all
         elsif @signed
             hosts = :signed
         else
-            hosts = command_line.args.collect { |h| puts h; h.downcase }
+            hosts = command_line.args.collect { |h| h.downcase }
         end
         begin
             @ca.apply(:revoke, :to => hosts) if @cert_mode == :destroy
             @ca.apply(@cert_mode, :to => hosts, :digest => @digest)
         rescue => detail
             puts detail.backtrace if Puppet[:trace]
             puts detail.to_s
             exit(24)
         end
     end
 
     def setup
         if Puppet.settings.print_configs?
             exit(Puppet.settings.print_configs ? 0 : 1)
         end
 
         Puppet::Util::Log.newdestination :console
 
         if @cert_mode == :generate
             Puppet::SSL::Host.ca_location = :local
         else
             Puppet::SSL::Host.ca_location = :only
         end
 
         begin
             @ca = Puppet::SSL::CertificateAuthority.new
         rescue => detail
             puts detail.backtrace if Puppet[:trace]
             puts detail.to_s
             exit(23)
         end
     end
 end
diff --git a/lib/puppet/util/run_mode.rb b/lib/puppet/util/run_mode.rb
index 029c1f921..fe9e07c85 100644
--- a/lib/puppet/util/run_mode.rb
+++ b/lib/puppet/util/run_mode.rb
@@ -1,81 +1,81 @@
 module Puppet
     module Util
         class RunMode
             def initialize(name)
                 @name = name.to_sym
             end
 
             @@run_modes = Hash.new {|h, k| h[k] = RunMode.new(k)}
 
             attr :name
 
             def self.[](name)
                 @@run_modes[name]
             end
 
             def master?
                 name == :master
             end
 
             def agent?
                 name == :agent
             end
 
             def user?
                 name == :user
             end
 
             def conf_dir
                 which_dir(
-                    (Puppet.features.win32? ? File.join(Dir::WINDOWS, "puppet", "etc") : "/etc/puppet"), 
+                    (Puppet.features.win32? ? File.join(Dir::WINDOWS, "puppet", "etc") : "/etc/puppet"),
                     "~/.puppet"
                 )
             end
 
             def var_dir
                 which_dir(
-                    (Puppet.features.win32? ? File.join(Dir::WINDOWS, "puppet", "var") : "/var/lib/puppet"), 
+                    (Puppet.features.win32? ? File.join(Dir::WINDOWS, "puppet", "var") : "/var/lib/puppet"),
                     "~/.puppet/var"
                 )
             end
 
             def run_dir
                 which_dir("/var/run/puppet", "~/.puppet/var")
             end
 
             def logopts
                 if name == :master
                     {
                         :default => "$vardir/log",
                         :mode => 0750,
                         :owner => "service",
                         :group => "service",
                         :desc => "The Puppet log directory."
                     }
                 else
                     ["$vardir/log", "The Puppet log directory."]
                 end
             end
 
             private
 
             def which_dir( global, user )
                 #FIXME: we should test if we're user "puppet"
                 #       there's a comment that suggests that we do that
                 #       and we currently don't.
                 expand_path case
                 when name == :master; global
                 when Puppet.features.root?; global
                 else user
                 end
             end
 
             def expand_path( dir )
                 require 'etc'
                 ENV["HOME"] ||= Etc.getpwuid(Process.uid).dir
                 File.expand_path(dir)
             end
 
         end
     end
 end
diff --git a/spec/unit/application/agent_spec.rb b/spec/unit/application/agent_spec.rb
index 21f5143bd..edaf04bb2 100755
--- a/spec/unit/application/agent_spec.rb
+++ b/spec/unit/application/agent_spec.rb
@@ -1,625 +1,629 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/agent'
 require 'puppet/application/agent'
 require 'puppet/network/server'
 require 'puppet/daemon'
 
 describe Puppet::Application::Agent do
     it "should ask Puppet::Application to parse Puppet configuration file" do
         agent = Puppet::Application::Agent.new
         agent.preinit
 
         Puppet[:vardir].should == '/dev/null'
         Puppet[:report].should be_false
 
         text = <<-CONF
             [main]
                 vardir='/foo/bar'
             [puppetd]
                 report=true
         CONF
 
         FileTest.expects(:exist?).with('file').returns true
         Puppet.settings.expects(:read_file).returns(text)
 
         Puppet.settings.unsafe_parse('file')
 
         Puppet[:vardir].should == '/foo/bar'
         Puppet[:report].should be_true
     end
 end
 
 describe Puppet::Application::Agent do
     before :each do
         @puppetd = Puppet::Application[:agent]
         @puppetd.stubs(:puts)
         @daemon = stub_everything 'daemon'
         Puppet::Daemon.stubs(:new).returns(@daemon)
         @agent = stub_everything 'agent'
         Puppet::Agent.stubs(:new).returns(@agent)
         @puppetd.preinit
         Puppet::Util::Log.stubs(:newdestination)
         Puppet::Util::Log.stubs(:level=)
 
         Puppet::Node.stubs(:terminus_class=)
         Puppet::Node.stubs(:cache_class=)
         Puppet::Node::Facts.stubs(:terminus_class=)
     end
 
+    it "should operate in agent run_mode" do
+        @puppetd.class.run_mode.name.should == :agent
+    end
+
     it "should ask Puppet::Application to parse Puppet configuration file" do
         @puppetd.should_parse_config?.should be_true
     end
 
     it "should declare a main command" do
         @puppetd.should respond_to(:main)
     end
 
     it "should declare a onetime command" do
         @puppetd.should respond_to(:onetime)
     end
 
     it "should declare a fingerprint command" do
         @puppetd.should respond_to(:fingerprint)
     end
 
     it "should declare a preinit block" do
         @puppetd.should respond_to(:preinit)
     end
 
     describe "in preinit" do
         before :each do
             @puppetd.stubs(:trap)
         end
 
         it "should catch INT" do
             @puppetd.expects(:trap).with { |arg,block| arg == :INT }
 
             @puppetd.preinit
         end
 
         it "should set waitforcert to 120" do
             @puppetd.preinit
 
             @puppetd.options[:waitforcert].should == 120
         end
 
         it "should init client to true" do
             @puppetd.preinit
 
             @puppetd.options[:client].should be_true
         end
 
         it "should init fqdn to nil" do
             @puppetd.preinit
 
             @puppetd.options[:fqdn].should be_nil
         end
 
         it "should init serve to []" do
             @puppetd.preinit
 
             @puppetd.options[:serve].should == []
         end
 
         it "should use MD5 as default digest algorithm" do
             @puppetd.preinit
 
             @puppetd.options[:digest].should == :MD5
         end
 
         it "should not fingerprint by default" do
             @puppetd.preinit
 
             @puppetd.options[:fingerprint].should be_false
         end
     end
 
     describe "when handling options" do
         before do
             @puppetd.command_line.stubs(:args).returns([])
         end
 
         [:centrallogging, :disable, :enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
             it "should declare handle_#{option} method" do
                 @puppetd.should respond_to("handle_#{option}".to_sym)
             end
 
             it "should store argument value when calling handle_#{option}" do
                 @puppetd.options.expects(:[]=).with(option, 'arg')
                 @puppetd.send("handle_#{option}".to_sym, 'arg')
             end
         end
 
         it "should set an existing handler on server" do
             Puppet::Network::Handler.stubs(:handler).with("handler").returns(true)
 
             @puppetd.handle_serve("handler")
             @puppetd.options[:serve].should == [ :handler ]
         end
 
         it "should set client to false with --no-client" do
             @puppetd.handle_no_client(nil)
             @puppetd.options[:client].should be_false
         end
 
         it "should set onetime to true with --onetime" do
             @puppetd.handle_onetime(nil)
             Puppet[:onetime].should be_true
         end
 
         it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
             @puppetd.explicit_waitforcert = false
             @puppetd.handle_onetime(nil)
             @puppetd.options[:waitforcert].should == 0
         end
 
         it "should not reset waitforcert with --onetime when --waitforcert is used" do
             @puppetd.explicit_waitforcert = true
             @puppetd.handle_onetime(nil)
             @puppetd.options[:waitforcert].should_not == 0
         end
 
         it "should set the log destination with --logdest" do
             @puppetd.options.stubs(:[]=).with { |opt,val| opt == :setdest }
             Puppet::Log.expects(:newdestination).with("console")
 
             @puppetd.handle_logdest("console")
         end
 
         it "should put the setdest options to true" do
             @puppetd.options.expects(:[]=).with(:setdest,true)
 
             @puppetd.handle_logdest("console")
         end
 
         it "should parse the log destination from the command line" do
             @puppetd.command_line.stubs(:args).returns(%w[--logdest /my/file])
 
             Puppet::Util::Log.expects(:newdestination).with("/my/file")
 
             @puppetd.parse_options
         end
 
         it "should store the waitforcert options with --waitforcert" do
             @puppetd.options.expects(:[]=).with(:waitforcert,42)
 
             @puppetd.handle_waitforcert("42")
         end
 
         it "should mark explicit_waitforcert to true with --waitforcert" do
             @puppetd.options.stubs(:[]=)
 
             @puppetd.handle_waitforcert("42")
             @puppetd.explicit_waitforcert.should be_true
         end
 
         it "should set args[:Port] with --port" do
             @puppetd.handle_port("42")
             @puppetd.args[:Port].should == "42"
         end
 
     end
 
     describe "during setup" do
         before :each do
             @puppetd.options.stubs(:[])
             Puppet.stubs(:info)
             FileTest.stubs(:exists?).returns(true)
             Puppet.stubs(:[])
             Puppet.stubs(:[]=)
             Puppet.stubs(:[]).with(:libdir).returns("/dev/null/lib")
             Puppet.settings.stubs(:print_config?)
             Puppet.settings.stubs(:print_config)
             Puppet::SSL::Host.stubs(:ca_location=)
             Puppet::Transaction::Report.stubs(:terminus_class=)
             Puppet::Resource::Catalog.stubs(:terminus_class=)
             Puppet::Resource::Catalog.stubs(:cache_class=)
             Puppet::Node::Facts.stubs(:terminus_class=)
             @host = stub_everything 'host'
             Puppet::SSL::Host.stubs(:new).returns(@host)
             Puppet.stubs(:settraps)
         end
 
         describe "with --test" do
             before :each do
                 Puppet.settings.stubs(:handlearg)
                 @puppetd.options.stubs(:[]=)
             end
 
             it "should call setup_test" do
                 @puppetd.options.stubs(:[]).with(:test).returns(true)
                 @puppetd.expects(:setup_test)
                 @puppetd.setup
             end
 
             it "should set options[:verbose] to true" do
                 @puppetd.options.expects(:[]=).with(:verbose,true)
                 @puppetd.setup_test
             end
             it "should set options[:onetime] to true" do
                 Puppet.expects(:[]=).with(:onetime,true)
                 @puppetd.setup_test
             end
             it "should set options[:detailed_exitcodes] to true" do
                 @puppetd.options.expects(:[]=).with(:detailed_exitcodes,true)
                 @puppetd.setup_test
             end
             it "should set waitforcert to 0" do
                 @puppetd.options.expects(:[]=).with(:waitforcert,0)
                 @puppetd.setup_test
             end
         end
 
         it "should call setup_logs" do
             @puppetd.expects(:setup_logs)
             @puppetd.setup
         end
 
         describe "when setting up logs" do
             before :each do
                 Puppet::Util::Log.stubs(:newdestination)
             end
 
             it "should set log level to debug if --debug was passed" do
                 @puppetd.options.stubs(:[]).with(:debug).returns(true)
 
                 Puppet::Util::Log.expects(:level=).with(:debug)
 
                 @puppetd.setup_logs
             end
 
             it "should set log level to info if --verbose was passed" do
                 @puppetd.options.stubs(:[]).with(:verbose).returns(true)
 
                 Puppet::Util::Log.expects(:level=).with(:info)
 
                 @puppetd.setup_logs
             end
 
             [:verbose, :debug].each do |level|
                 it "should set console as the log destination with level #{level}" do
                     @puppetd.options.stubs(:[]).with(level).returns(true)
 
                     Puppet::Util::Log.expects(:newdestination).with(:console)
 
                     @puppetd.setup_logs
                 end
             end
 
             it "should set syslog as the log destination if no --logdest" do
                 @puppetd.options.stubs(:[]).with(:setdest).returns(false)
 
                 Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
                 @puppetd.setup_logs
             end
 
         end
 
         it "should print puppet config if asked to in Puppet config" do
             @puppetd.stubs(:exit)
             Puppet.settings.stubs(:print_configs?).returns(true)
 
             Puppet.settings.expects(:print_configs)
 
             @puppetd.setup
         end
 
         it "should exit after printing puppet config if asked to in Puppet config" do
             Puppet.settings.stubs(:print_configs?).returns(true)
 
             lambda { @puppetd.setup }.should raise_error(SystemExit)
         end
 
         it "should set a central log destination with --centrallogs" do
             @puppetd.options.stubs(:[]).with(:centrallogs).returns(true)
             Puppet.stubs(:[]).with(:server).returns("puppet.reductivelabs.com")
             Puppet::Util::Log.stubs(:newdestination).with(:syslog)
 
             Puppet::Util::Log.expects(:newdestination).with("puppet.reductivelabs.com")
 
             @puppetd.setup
         end
 
         it "should use :main, :puppetd, and :ssl" do
             Puppet.settings.expects(:use).with(:main, :agent, :ssl)
 
             @puppetd.setup
         end
 
         it "should install a remote ca location" do
             Puppet::SSL::Host.expects(:ca_location=).with(:remote)
 
             @puppetd.setup
         end
 
         it "should install a none ca location in fingerprint mode" do
             @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
             Puppet::SSL::Host.expects(:ca_location=).with(:none)
 
             @puppetd.setup
         end
 
         it "should tell the report handler to use REST" do
             Puppet::Transaction::Report.expects(:terminus_class=).with(:rest)
 
             @puppetd.setup
         end
 
         it "should change the catalog_terminus setting to 'rest'" do
             Puppet.expects(:[]=).with(:catalog_terminus, :rest)
             @puppetd.setup
         end
 
         it "should tell the catalog handler to use cache" do
             Puppet::Resource::Catalog.expects(:cache_class=).with(:yaml)
 
             @puppetd.setup
         end
 
         it "should change the facts_terminus setting to 'facter'" do
             Puppet.expects(:[]=).with(:facts_terminus, :facter)
 
             @puppetd.setup
         end
 
         it "should create an agent" do
             Puppet::Agent.stubs(:new).with(Puppet::Configurer)
 
             @puppetd.setup
         end
 
         [:enable, :disable].each do |action|
             it "should delegate to enable_disable_client if we #{action} the agent" do
                 @puppetd.options.stubs(:[]).with(action).returns(true)
                 @puppetd.expects(:enable_disable_client).with(@agent)
 
                 @puppetd.setup
             end
         end
 
         describe "when enabling or disabling agent" do
             [:enable, :disable].each do |action|
                 it "should call client.#{action}" do
                     @puppetd.stubs(:exit)
                     @puppetd.options.stubs(:[]).with(action).returns(true)
 
                     @agent.expects(action)
 
                     @puppetd.enable_disable_client(@agent)
                 end
             end
 
             it "should finally exit" do
                 lambda { @puppetd.enable_disable_client(@agent) }.should raise_error(SystemExit)
             end
         end
 
         it "should inform the daemon about our agent if :client is set to 'true'" do
             @puppetd.options.expects(:[]).with(:client).returns true
             @daemon.expects(:agent=).with(@agent)
             @puppetd.setup
         end
 
         it "should not inform the daemon about our agent if :client is set to 'false'" do
             @puppetd.options[:client] = false
             @daemon.expects(:agent=).never
             @puppetd.setup
         end
 
         it "should daemonize if needed" do
             Puppet.stubs(:[]).with(:daemonize).returns(true)
 
             @daemon.expects(:daemonize)
 
             @puppetd.setup
         end
 
         it "should wait for a certificate" do
             @puppetd.options.stubs(:[]).with(:waitforcert).returns(123)
             @host.expects(:wait_for_cert).with(123)
 
             @puppetd.setup
         end
 
         it "should not wait for a certificate in fingerprint mode" do
             @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
             @puppetd.options.stubs(:[]).with(:waitforcert).returns(123)
             @host.expects(:wait_for_cert).never
 
             @puppetd.setup
         end
 
         it "should setup listen if told to and not onetime" do
             Puppet.stubs(:[]).with(:listen).returns(true)
             @puppetd.options.stubs(:[]).with(:onetime).returns(false)
 
             @puppetd.expects(:setup_listen)
 
             @puppetd.setup
         end
 
         describe "when setting up listen" do
             before :each do
                 Puppet.stubs(:[]).with(:authconfig).returns('auth')
                 FileTest.stubs(:exists?).with('auth').returns(true)
                 File.stubs(:exist?).returns(true)
                 @puppetd.options.stubs(:[]).with(:serve).returns([])
                 @puppetd.stubs(:exit)
                 @server = stub_everything 'server'
                 Puppet::Network::Server.stubs(:new).returns(@server)
             end
 
 
             it "should exit if no authorization file" do
                 Puppet.stubs(:err)
                 FileTest.stubs(:exists?).with('auth').returns(false)
 
                 @puppetd.expects(:exit)
 
                 @puppetd.setup_listen
             end
 
             it "should create a server to listen on at least the Runner handler" do
                 Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:Runner] }
 
                 @puppetd.setup_listen
             end
 
             it "should create a server to listen for specific handlers" do
                 @puppetd.options.stubs(:[]).with(:serve).returns([:handler])
                 Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:handler] }
 
                 @puppetd.setup_listen
             end
 
             it "should use puppet default port" do
                 Puppet.stubs(:[]).with(:puppetport).returns(:port)
 
                 Puppet::Network::Server.expects(:new).with { |args| args[:port] == :port }
 
                 @puppetd.setup_listen
             end
         end
     end
 
 
     describe "when running" do
         before :each do
             @puppetd.agent = @agent
             @puppetd.daemon = @daemon
             @puppetd.options.stubs(:[]).with(:fingerprint).returns(false)
         end
 
         it "should dispatch to fingerprint if --fingerprint is used" do
             @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
 
             @puppetd.stubs(:fingerprint)
             @puppetd.run_command
         end
 
         it "should dispatch to onetime if --onetime is used" do
             @puppetd.options.stubs(:[]).with(:onetime).returns(true)
 
             @puppetd.stubs(:onetime)
             @puppetd.run_command
         end
 
         it "should dispatch to main if --onetime and --fingerprint are not used" do
             @puppetd.options.stubs(:[]).with(:onetime).returns(false)
 
             @puppetd.stubs(:main)
             @puppetd.run_command
         end
 
         describe "with --onetime" do
 
             before :each do
                 @agent.stubs(:run).returns(:report)
                 @puppetd.options.stubs(:[]).with(:client).returns(:client)
                 @puppetd.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
                 @puppetd.stubs(:exit).with(0)
                 Puppet.stubs(:newservice)
             end
 
             it "should exit if no defined --client" do
                 $stderr.stubs(:puts)
                 @puppetd.options.stubs(:[]).with(:client).returns(nil)
 
                 @puppetd.expects(:exit).with(43)
 
                 @puppetd.onetime
             end
 
             it "should setup traps" do
                 @daemon.expects(:set_signal_traps)
 
                 @puppetd.onetime
             end
 
             it "should let the agent run" do
                 @agent.expects(:run).returns(:report)
 
                 @puppetd.onetime
             end
 
             it "should finish by exiting with 0 error code" do
                 @puppetd.expects(:exit).with(0)
 
                 @puppetd.onetime
             end
 
             describe "and --detailed-exitcodes" do
                 before :each do
                     @puppetd.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
                 end
 
                 it "should exit with report's computed exit status" do
                     Puppet.stubs(:[]).with(:noop).returns(false)
                     report = stub 'report', :exit_status => 666
                     @agent.stubs(:run).returns(report)
                     @puppetd.expects(:exit).with(666)
 
                     @puppetd.onetime
                 end
 
                 it "should always exit with 0 if --noop" do
                     Puppet.stubs(:[]).with(:noop).returns(true)
                     report = stub 'report', :exit_status => 666
                     @agent.stubs(:run).returns(report)
                     @puppetd.expects(:exit).with(0)
 
                     @puppetd.onetime
                 end
             end
         end
 
         describe "with --fingerprint" do
             before :each do
                 @cert = stub_everything 'cert'
                 @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
                 @puppetd.options.stubs(:[]).with(:digest).returns(:MD5)
                 @host = stub_everything 'host'
                 @puppetd.stubs(:host).returns(@host)
             end
 
             it "should fingerprint the certificate if it exists" do
                 @host.expects(:certificate).returns(@cert)
                 @cert.expects(:fingerprint).with(:MD5).returns "fingerprint"
                 @puppetd.fingerprint
             end
 
             it "should fingerprint the certificate request if no certificate have been signed" do
                 @host.expects(:certificate).returns(nil)
                 @host.expects(:certificate_request).returns(@cert)
                 @cert.expects(:fingerprint).with(:MD5).returns "fingerprint"
                 @puppetd.fingerprint
             end
 
             it "should display the fingerprint" do
                 @host.stubs(:certificate).returns(@cert)
                 @cert.stubs(:fingerprint).with(:MD5).returns("DIGEST")
 
                 Puppet.expects(:notice).with("DIGEST")
 
                 @puppetd.fingerprint
             end
         end
 
         describe "without --onetime and --fingerprint" do
             before :each do
                 Puppet.stubs(:notice)
                 @puppetd.options.stubs(:[]).with(:client)
             end
 
             it "should start our daemon" do
                 @daemon.expects(:start)
 
                 @puppetd.main
             end
         end
     end
 end
diff --git a/spec/unit/application/cert_spec.rb b/spec/unit/application/cert_spec.rb
index 871c9d17d..a72532e50 100755
--- a/spec/unit/application/cert_spec.rb
+++ b/spec/unit/application/cert_spec.rb
@@ -1,172 +1,176 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/cert'
 
 describe Puppet::Application::Cert do
     before :each do
         @cert_app = Puppet::Application[:cert]
         Puppet::Util::Log.stubs(:newdestination)
         Puppet::Util::Log.stubs(:level=)
     end
 
+    it "should operate in master run_mode" do
+        @cert_app.class.run_mode.name.should equal :master
+    end
+
     it "should ask Puppet::Application to parse Puppet configuration file" do
         @cert_app.should_parse_config?.should be_true
     end
 
     it "should declare a main command" do
         @cert_app.should respond_to(:main)
     end
 
     Puppet::SSL::CertificateAuthority::Interface::INTERFACE_METHODS.reject{ |m| m == :destroy }.each do |method|
         it "should declare option --#{method}" do
             @cert_app.should respond_to("handle_#{method}".to_sym)
         end
     end
 
     it "should set log level to info with the --verbose option" do
 
         Puppet::Log.expects(:level=).with(:info)
 
         @cert_app.handle_verbose(0)
     end
 
     it "should set log level to debug with the --debug option" do
 
         Puppet::Log.expects(:level=).with(:debug)
 
         @cert_app.handle_debug(0)
     end
 
     it "should set the fingerprint digest with the --digest option" do
         @cert_app.handle_digest(:digest)
 
         @cert_app.digest.should == :digest
     end
 
     it "should set cert_mode to :destroy for --clean" do
         @cert_app.handle_clean(0)
         @cert_app.cert_mode.should == :destroy
     end
 
     it "should set all to true for --all" do
         @cert_app.handle_all(0)
         @cert_app.all.should be_true
     end
 
     it "should set signed to true for --signed" do
         @cert_app.handle_signed(0)
         @cert_app.signed.should be_true
     end
-    
+
     Puppet::SSL::CertificateAuthority::Interface::INTERFACE_METHODS.reject { |m| m == :destroy }.each do |method|
         it "should set cert_mode to #{method} with option --#{method}" do
             @cert_app.send("handle_#{method}".to_sym, nil)
 
             @cert_app.cert_mode.should == method
         end
     end
 
     describe "during setup" do
 
         before :each do
             Puppet::Log.stubs(:newdestination)
             Puppet::SSL::Host.stubs(:ca_location=)
             Puppet::SSL::CertificateAuthority.stubs(:new)
         end
 
         it "should set console as the log destination" do
             Puppet::Log.expects(:newdestination).with(:console)
 
             @cert_app.setup
         end
 
         it "should print puppet config if asked to in Puppet config" do
             @cert_app.stubs(:exit)
             Puppet.settings.stubs(:print_configs?).returns(true)
 
             Puppet.settings.expects(:print_configs)
 
             @cert_app.setup
         end
 
         it "should exit after printing puppet config if asked to in Puppet config" do
             Puppet.settings.stubs(:print_configs?).returns(true)
 
             lambda { @cert_app.setup }.should raise_error(SystemExit)
         end
 
         it "should set the CA location to 'only'" do
             Puppet::SSL::Host.expects(:ca_location=).with(:only)
 
             @cert_app.setup
         end
 
         it "should create a new certificate authority" do
             Puppet::SSL::CertificateAuthority.expects(:new)
 
             @cert_app.setup
         end
     end
 
     describe "when running" do
         before :each do
             @cert_app.all = false
             @ca = stub_everything 'ca'
             @cert_app.ca = @ca
             @cert_app.command_line.stubs(:args).returns([])
         end
 
         it "should delegate to the CertificateAuthority" do
             @ca.expects(:apply)
 
             @cert_app.main
         end
 
         it "should delegate with :all if option --all was given" do
             @cert_app.handle_all(0)
 
             @ca.expects(:apply).with { |cert_mode,to| to[:to] == :all }
 
             @cert_app.main
         end
 
         it "should delegate to ca.apply with the hosts given on command line" do
             @cert_app.command_line.stubs(:args).returns(["host"])
 
             @ca.expects(:apply).with { |cert_mode,to| to[:to] == ["host"]}
 
             @cert_app.main
         end
 
         it "should send the currently set digest" do
             @cert_app.command_line.stubs(:args).returns(["host"])
             @cert_app.handle_digest(:digest)
 
             @ca.expects(:apply).with { |cert_mode,to| to[:digest] == :digest}
 
             @cert_app.main
         end
 
         it "should delegate to ca.apply with current set cert_mode" do
             @cert_app.cert_mode = "currentmode"
             @cert_app.command_line.stubs(:args).returns(["host"])
 
             @ca.expects(:apply).with { |cert_mode,to| cert_mode == "currentmode" }
 
             @cert_app.main
         end
 
         it "should revoke cert if cert_mode is clean" do
             @cert_app.cert_mode = :destroy
             @cert_app.command_line.stubs(:args).returns(["host"])
 
             @ca.expects(:apply).with { |cert_mode,to| cert_mode == :revoke }
             @ca.expects(:apply).with { |cert_mode,to| cert_mode == :destroy }
 
             @cert_app.main
         end
 
     end
 end
diff --git a/spec/unit/application/master_spec.rb b/spec/unit/application/master_spec.rb
index c3f4d9e37..419f63dc7 100644
--- a/spec/unit/application/master_spec.rb
+++ b/spec/unit/application/master_spec.rb
@@ -1,447 +1,453 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/master'
+require 'puppet/daemon'
+require 'puppet/network/server'
 
 describe Puppet::Application::Master do
     before :each do
         @master = Puppet::Application[:master]
         @daemon = stub_everything 'daemon'
         Puppet::Daemon.stubs(:new).returns(@daemon)
         Puppet::Util::Log.stubs(:newdestination)
         Puppet::Util::Log.stubs(:level=)
 
         Puppet::Node.stubs(:terminus_class=)
         Puppet::Node.stubs(:cache_class=)
         Puppet::Node::Facts.stubs(:terminus_class=)
         Puppet::Node::Facts.stubs(:cache_class=)
         Puppet::Transaction::Report.stubs(:terminus_class=)
         Puppet::Resource::Catalog.stubs(:terminus_class=)
     end
 
+    it "should operate in master run_mode" do
+        @master.class.run_mode.name.should equal :master
+    end
+
     it "should ask Puppet::Application to parse Puppet configuration file" do
         @master.should_parse_config?.should be_true
     end
 
     it "should declare a main command" do
         @master.should respond_to(:main)
     end
 
     it "should declare a parseonly command" do
         @master.should respond_to(:parseonly)
     end
 
     it "should declare a compile command" do
         @master.should respond_to(:compile)
     end
 
     it "should declare a preinit block" do
         @master.should respond_to(:preinit)
     end
 
     describe "during preinit" do
         before :each do
             @master.stubs(:trap)
         end
 
         it "should catch INT" do
             @master.stubs(:trap).with { |arg,block| arg == :INT }
 
             @master.preinit
         end
 
         it "should create a Puppet Daemon" do
             Puppet::Daemon.expects(:new).returns(@daemon)
 
             @master.preinit
         end
 
         it "should give ARGV to the Daemon" do
             argv = stub 'argv'
             ARGV.stubs(:dup).returns(argv)
             @daemon.expects(:argv=).with(argv)
 
             @master.preinit
         end
 
     end
 
     [:debug,:verbose].each do |option|
         it "should declare handle_#{option} method" do
             @master.should respond_to("handle_#{option}".to_sym)
         end
 
         it "should store argument value when calling handle_#{option}" do
             @master.options.expects(:[]=).with(option, 'arg')
             @master.send("handle_#{option}".to_sym, 'arg')
         end
     end
 
     describe "when applying options" do
         before do
             @master.command_line.stubs(:args).returns([])
         end
 
         it "should set the log destination with --logdest" do
             Puppet::Log.expects(:newdestination).with("console")
 
             @master.handle_logdest("console")
         end
 
         it "should put the setdest options to true" do
             @master.options.expects(:[]=).with(:setdest,true)
 
             @master.handle_logdest("console")
         end
 
         it "should parse the log destination from ARGV" do
             @master.command_line.stubs(:args).returns(%w[--logdest /my/file])
 
             Puppet::Util::Log.expects(:newdestination).with("/my/file")
 
             @master.parse_options
         end
     end
 
     describe "during setup" do
 
         before :each do
             Puppet::Log.stubs(:newdestination)
             Puppet.stubs(:settraps)
             Puppet::Log.stubs(:level=)
             Puppet::SSL::CertificateAuthority.stubs(:instance)
             Puppet::SSL::CertificateAuthority.stubs(:ca?)
             Puppet.settings.stubs(:use)
 
             @master.options.stubs(:[]).with(any_parameters)
         end
 
         it "should set log level to debug if --debug was passed" do
             @master.options.stubs(:[]).with(:debug).returns(true)
 
             Puppet::Log.expects(:level=).with(:debug)
 
             @master.setup
         end
 
         it "should set log level to info if --verbose was passed" do
             @master.options.stubs(:[]).with(:verbose).returns(true)
 
             Puppet::Log.expects(:level=).with(:info)
 
             @master.setup
         end
 
         it "should set console as the log destination if no --logdest and --daemonize" do
             @master.stubs(:[]).with(:daemonize).returns(:false)
 
             Puppet::Log.expects(:newdestination).with(:syslog)
 
             @master.setup
         end
 
         it "should set syslog as the log destination if no --logdest and not --daemonize" do
             Puppet::Log.expects(:newdestination).with(:syslog)
 
             @master.setup
         end
 
         it "should set syslog as the log destination if --rack" do
             @master.options.stubs(:[]).with(:rack).returns(:true)
 
             Puppet::Log.expects(:newdestination).with(:syslog)
 
             @master.setup
         end
 
         it "should print puppet config if asked to in Puppet config" do
             @master.stubs(:exit)
             Puppet.settings.stubs(:print_configs?).returns(true)
 
             Puppet.settings.expects(:print_configs)
 
             @master.setup
         end
 
         it "should exit after printing puppet config if asked to in Puppet config" do
             Puppet.settings.stubs(:print_configs?).returns(true)
 
             lambda { @master.setup }.should raise_error(SystemExit)
         end
 
         it "should tell Puppet.settings to use :main,:ssl and :master category" do
             Puppet.settings.expects(:use).with(:main,:master,:ssl)
 
             @master.setup
         end
 
         it "should cache class in yaml" do
             Puppet::Node.expects(:cache_class=).with(:yaml)
 
             @master.setup
         end
 
         describe "with no ca" do
 
             it "should set the ca_location to none" do
                 Puppet::SSL::Host.expects(:ca_location=).with(:none)
 
                 @master.setup
             end
 
         end
 
         describe "with a ca configured" do
 
             before :each do
                 Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
             end
 
             it "should set the ca_location to local" do
                 Puppet::SSL::Host.expects(:ca_location=).with(:local)
 
                 @master.setup
             end
 
             it "should tell Puppet.settings to use :ca category" do
                 Puppet.settings.expects(:use).with(:ca)
 
                 @master.setup
             end
 
             it "should instantiate the CertificateAuthority singleton" do
                 Puppet::SSL::CertificateAuthority.expects(:instance)
 
                 @master.setup
             end
 
 
         end
 
     end
 
     describe "when running" do
         before do
             @master.preinit
         end
 
         it "should dispatch to parseonly if parseonly is set" do
             Puppet.stubs(:[]).with(:parseonly).returns(true)
             @master.options[:node] = nil
 
             @master.expects(:parseonly)
             @master.run_command
         end
 
         it "should dispatch to compile if called with --compile" do
             @master.options[:node] = "foo"
             @master.expects(:compile)
             @master.run_command
         end
 
         it "should dispatch to main if parseonly is not set" do
             Puppet.stubs(:[]).with(:parseonly).returns(false)
             @master.options[:node] = nil
 
             @master.expects(:main)
             @master.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)
                 @master.stubs(:exit)
                 @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)
                 @master.parseonly
             end
 
             it "should exit with exit code 0 if no error" do
                 @master.expects(:exit).with(0)
                 @master.parseonly
             end
 
             it "should exit with exit code 1 if error" do
                 @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
                 @master.expects(:exit).with(1)
                 @master.parseonly
             end
         end
 
         describe "the compile command" do
             before do
                 Puppet.stubs(:[]).with(:environment)
                 Puppet.stubs(:[]).with(:manifest).returns("site.pp")
                 Puppet.stubs(:err)
                 @master.stubs(:jj)
                 @master.stubs(:exit)
                 Puppet.features.stubs(:pson?).returns true
             end
 
             it "should fail if pson isn't available" do
                 Puppet.features.expects(:pson?).returns false
                 lambda { @master.compile }.should raise_error
             end
 
             it "should compile a catalog for the specified node" do
                 @master.options[:node] = "foo"
                 Puppet::Resource::Catalog.expects(:find).with("foo").returns Puppet::Resource::Catalog.new
                 $stdout.stubs(:puts)
 
                 @master.compile
             end
 
             it "should convert the catalog to a pure-resource catalog and use 'jj' to pretty-print the catalog" do
                 catalog = Puppet::Resource::Catalog.new
                 Puppet::Resource::Catalog.expects(:find).returns catalog
 
                 catalog.expects(:to_resource).returns("rescat")
 
                 @master.options[:node] = "foo"
                 @master.expects(:jj).with("rescat")
 
                 @master.compile
             end
 
             it "should exit with error code 30 if no catalog can be found" do
                 @master.options[:node] = "foo"
                 Puppet::Resource::Catalog.expects(:find).returns nil
                 @master.expects(:exit).with(30)
                 $stderr.expects(:puts)
 
                 @master.compile
             end
 
             it "should exit with error code 30 if there's a failure" do
                 @master.options[:node] = "foo"
                 Puppet::Resource::Catalog.expects(:find).raises ArgumentError
                 @master.expects(:exit).with(30)
                 $stderr.expects(:puts)
 
                 @master.compile
             end
         end
 
         describe "the main command" do
             before :each do
                 @master.preinit
                 @server = stub_everything 'server'
                 Puppet::Network::Server.stubs(:new).returns(@server)
                 @app = stub_everything 'app'
                 Puppet::SSL::Host.stubs(:localhost)
                 Puppet::SSL::CertificateAuthority.stubs(:ca?)
                 Process.stubs(:uid).returns(1000)
                 Puppet.stubs(:service)
                 Puppet.stubs(:[])
                 Puppet.stubs(:notice)
                 Puppet.stubs(:start)
             end
 
             it "should create a Server" do
                 Puppet::Network::Server.expects(:new)
 
                 @master.main
             end
 
             it "should give the server to the daemon" do
                 @daemon.expects(:server=).with(@server)
 
                 @master.main
             end
 
             it "should create the server with the right XMLRPC handlers" do
                 Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:Status, :FileServer, :Master, :Report, :Filebucket]}
 
                 @master.main
             end
 
             it "should create the server with a :ca xmlrpc handler if needed" do
                 Puppet.stubs(:[]).with(:ca).returns(true)
                 Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers].include?(:CA) }
 
                 @master.main
             end
 
             it "should generate a SSL cert for localhost" do
                 Puppet::SSL::Host.expects(:localhost)
 
                 @master.main
             end
 
             it "should make sure to *only* hit the CA for data" do
                 Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
 
                 Puppet::SSL::Host.expects(:ca_location=).with(:only)
 
                 @master.main
             end
 
             it "should drop privileges if running as root" do
                 Puppet.features.stubs(:root?).returns true
 
                 Puppet::Util.expects(:chuser)
 
                 @master.main
             end
 
             it "should daemonize if needed" do
                 Puppet.stubs(:[]).with(:daemonize).returns(true)
 
                 @daemon.expects(:daemonize)
 
                 @master.main
             end
 
             it "should start the service" do
                 @daemon.expects(:start)
 
                 @master.main
             end
 
             describe "with --rack" do
                 confine "Rack is not available" => Puppet.features.rack?
 
                 before do
                     require 'puppet/network/http/rack'
                     Puppet::Network::HTTP::Rack.stubs(:new).returns(@app)
                 end
 
                 it "it should create the app with REST and XMLRPC support" do
                     @master.options.stubs(:[]).with(:rack).returns(:true)
 
                     Puppet::Network::HTTP::Rack.expects(:new).with { |args|
                         args[:xmlrpc_handlers] == [:Status, :FileServer, :Master, :Report, :Filebucket] and
                         args[:protocols] == [:rest, :xmlrpc]
                     }
 
                     @master.main
                 end
 
                 it "it should not start a daemon" do
                     @master.options.stubs(:[]).with(:rack).returns(:true)
 
                     @daemon.expects(:start).never
 
                     @master.main
                 end
 
                 it "it should return the app" do
                     @master.options.stubs(:[]).with(:rack).returns(:true)
 
                     app = @master.main
                     app.should equal(@app)
                 end
 
             end
 
         end
     end
 end