puppet 0.25.5 → 2.6.0

data/spec/unit/agent/locker_spec.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/agent'
+require 'puppet/agent/locker'
+
+class LockerTester
+  include Puppet::Agent::Locker
+end
+
+describe Puppet::Agent::Locker do
+  before do
+    @locker = LockerTester.new
+    @locker.stubs(:lockfile_path).returns "/my/lock"
+  end
+
+  it "should use a Pidlock instance as its lockfile" do
+    @locker.lockfile.should be_instance_of(Puppet::Util::Pidlock)
+  end
+
+  it "should use 'lockfile_path' to determine its lockfile path" do
+    @locker.expects(:lockfile_path).returns "/my/lock"
+    lock = Puppet::Util::Pidlock.new("/my/lock")
+    Puppet::Util::Pidlock.expects(:new).with("/my/lock").returns lock
+
+    @locker.lockfile
+  end
+
+  it "should reuse the same lock file each time" do
+    @locker.lockfile.should equal(@locker.lockfile)
+  end
+
+  it "should use the lock file to anonymously lock the process when disabled" do
+    @locker.lockfile.expects(:lock).with(:anonymous => true)
+
+    @locker.disable
+  end
+
+  it "should use the lock file to anonymously unlock the process when enabled" do
+    @locker.lockfile.expects(:unlock).with(:anonymous => true)
+
+    @locker.enable
+  end
+
+  it "should have a method that yields when a lock is attained" do
+    @locker.lockfile.expects(:lock).returns true
+
+    yielded = false
+    @locker.lock do
+      yielded = true
+    end
+    yielded.should be_true
+  end
+
+  it "should return true when the lock method successfully locked" do
+    @locker.lockfile.expects(:lock).returns true
+
+    @locker.lock {}.should be_true
+  end
+
+  it "should return true when the lock method does not receive the lock" do
+    @locker.lockfile.expects(:lock).returns false
+
+    @locker.lock {}.should be_false
+  end
+
+  it "should not yield when the lock method does not receive the lock" do
+    @locker.lockfile.expects(:lock).returns false
+
+    yielded = false
+    @locker.lock { yielded = true }
+    yielded.should be_false
+  end
+
+  it "should not unlock when a lock was not received" do
+    @locker.lockfile.expects(:lock).returns false
+    @locker.lockfile.expects(:unlock).never
+
+    @locker.lock {}
+  end
+
+  it "should unlock after yielding upon obtaining a lock" do
+    @locker.lockfile.stubs(:lock).returns true
+    @locker.lockfile.expects(:unlock)
+
+    @locker.lock {}
+  end
+
+  it "should unlock after yielding upon obtaining a lock, even if the block throws an exception" do
+    @locker.lockfile.stubs(:lock).returns true
+    @locker.lockfile.expects(:unlock)
+
+    lambda { @locker.lock { raise "foo" } }.should raise_error(RuntimeError)
+  end
+
+  it "should be considered running if the lockfile is locked" do
+    @locker.lockfile.expects(:locked?).returns true
+    @locker.should be_running
+  end
+end

data/spec/unit/agent_spec.rb

@@ -0,0 +1,281 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-11-12.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'puppet/agent'
+
+class AgentTestClient
+  def run
+    # no-op
+  end
+  def stop
+    # no-op
+  end
+end
+
+def without_warnings
+  flag = $VERBOSE
+  $VERBOSE = nil
+  yield
+  $VERBOSE = flag
+end
+
+describe Puppet::Agent do
+  before do
+    @agent = Puppet::Agent.new(AgentTestClient)
+
+    # So we don't actually try to hit the filesystem.
+    @agent.stubs(:lock).yields
+
+    # make Puppet::Application safe for stubbing; restore in an :after block; silence warnings for this.
+    without_warnings { Puppet::Application = Class.new(Puppet::Application) }
+    Puppet::Application.stubs(:clear?).returns(true)
+    Puppet::Application.class_eval do
+      class << self
+        def controlled_run(&block)
+          block.call
+        end
+      end
+    end
+  end
+
+  after do
+    # restore Puppet::Application from stub-safe subclass, and silence warnings
+    without_warnings { Puppet::Application = Puppet::Application.superclass }
+  end
+
+  it "should set its client class at initialization" do
+    Puppet::Agent.new("foo").client_class.should == "foo"
+  end
+
+  it "should include the Locker module" do
+    Puppet::Agent.ancestors.should be_include(Puppet::Agent::Locker)
+  end
+
+  it "should create an instance of its client class and run it when asked to run" do
+    client = mock 'client'
+    AgentTestClient.expects(:new).returns client
+
+    client.expects(:run)
+
+    @agent.stubs(:running?).returns false
+    @agent.run
+  end
+
+  it "should determine its lock file path by asking the client class" do
+    AgentTestClient.expects(:lockfile_path).returns "/my/lock"
+    @agent.lockfile_path.should == "/my/lock"
+  end
+
+  it "should be considered running if the lock file is locked" do
+    lockfile = mock 'lockfile'
+
+    @agent.expects(:lockfile).returns lockfile
+    lockfile.expects(:locked?).returns true
+
+    @agent.should be_running
+  end
+
+  describe "when being run" do
+    before do
+      @agent.stubs(:running?).returns false
+    end
+
+    it "should splay" do
+      @agent.expects(:splay)
+      @agent.stubs(:running?).returns false
+
+      @agent.run
+    end
+
+    it "should do nothing if already running" do
+      @agent.expects(:running?).returns true
+      AgentTestClient.expects(:new).never
+      @agent.run
+    end
+
+    it "should use Puppet::Application.controlled_run to manage process state behavior" do
+      calls = sequence('calls')
+      Puppet::Application.expects(:controlled_run).yields.in_sequence(calls)
+      AgentTestClient.expects(:new).once.in_sequence(calls)
+      @agent.run
+    end
+
+    it "should not fail if a client class instance cannot be created" do
+      AgentTestClient.expects(:new).raises "eh"
+      Puppet.expects(:err)
+      @agent.run
+    end
+
+    it "should not fail if there is an exception while running its client" do
+      client = AgentTestClient.new
+      AgentTestClient.expects(:new).returns client
+      client.expects(:run).raises "eh"
+      Puppet.expects(:err)
+      @agent.run
+    end
+
+    it "should use a mutex to restrict multi-threading" do
+      client = AgentTestClient.new
+      AgentTestClient.expects(:new).returns client
+
+      mutex = mock 'mutex'
+      @agent.expects(:sync).returns mutex
+
+      mutex.expects(:synchronize)
+      client.expects(:run).never # if it doesn't run, then we know our yield is what triggers it
+      @agent.run
+    end
+
+    it "should use a filesystem lock to restrict multiple processes running the agent" do
+      client = AgentTestClient.new
+      AgentTestClient.expects(:new).returns client
+
+      @agent.expects(:lock)
+
+      client.expects(:run).never # if it doesn't run, then we know our yield is what triggers it
+      @agent.run
+    end
+
+    it "should make its client instance available while running" do
+      client = AgentTestClient.new
+      AgentTestClient.expects(:new).returns client
+
+      client.expects(:run).with { @agent.client.should equal(client); true }
+      @agent.run
+    end
+
+    it "should run the client instance with any arguments passed to it" do
+      client = AgentTestClient.new
+      AgentTestClient.expects(:new).returns client
+
+      client.expects(:run).with("testargs")
+      @agent.run("testargs")
+    end
+  end
+
+  describe "when splaying" do
+    before do
+      Puppet.settings.stubs(:value).with(:splay).returns true
+      Puppet.settings.stubs(:value).with(:splaylimit).returns "10"
+    end
+
+    it "should do nothing if splay is disabled" do
+      Puppet.settings.expects(:value).returns false
+      @agent.expects(:sleep).never
+      @agent.splay
+    end
+
+    it "should do nothing if it has already splayed" do
+      @agent.expects(:splayed?).returns true
+      @agent.expects(:sleep).never
+      @agent.splay
+    end
+
+    it "should log that it is splaying" do
+      @agent.stubs :sleep
+      Puppet.expects :info
+      @agent.splay
+    end
+
+    it "should sleep for a random portion of the splaylimit plus 1" do
+      Puppet.settings.expects(:value).with(:splaylimit).returns "50"
+      @agent.expects(:rand).with(51).returns 10
+      @agent.expects(:sleep).with(10)
+      @agent.splay
+    end
+
+    it "should mark that it has splayed" do
+      @agent.stubs(:sleep)
+      @agent.splay
+      @agent.should be_splayed
+    end
+  end
+
+  describe "when checking execution state" do
+    describe 'with regular run status' do
+      before :each do
+        Puppet::Application.stubs(:restart_requested?).returns(false)
+        Puppet::Application.stubs(:stop_requested?).returns(false)
+        Puppet::Application.stubs(:interrupted?).returns(false)
+        Puppet::Application.stubs(:clear?).returns(true)
+      end
+
+      it 'should be false for :stopping?' do
+        @agent.stopping?.should be_false
+      end
+
+      it 'should be false for :needing_restart?' do
+        @agent.needing_restart?.should be_false
+      end
+    end
+
+    describe 'with a stop requested' do
+      before :each do
+        Puppet::Application.stubs(:clear?).returns(false)
+        Puppet::Application.stubs(:restart_requested?).returns(false)
+        Puppet::Application.stubs(:stop_requested?).returns(true)
+        Puppet::Application.stubs(:interrupted?).returns(true)
+      end
+
+      it 'should be true for :stopping?' do
+        @agent.stopping?.should be_true
+      end
+
+      it 'should be false for :needing_restart?' do
+        @agent.needing_restart?.should be_false
+      end
+    end
+
+    describe 'with a restart requested' do
+      before :each do
+        Puppet::Application.stubs(:clear?).returns(false)
+        Puppet::Application.stubs(:restart_requested?).returns(true)
+        Puppet::Application.stubs(:stop_requested?).returns(false)
+        Puppet::Application.stubs(:interrupted?).returns(true)
+      end
+
+      it 'should be false for :stopping?' do
+        @agent.stopping?.should be_false
+      end
+
+      it 'should be true for :needing_restart?' do
+        @agent.needing_restart?.should be_true
+      end
+    end
+  end
+
+  describe "when starting" do
+    before do
+      @agent.stubs(:observe_signal)
+    end
+
+    it "should create a timer with the runinterval, a tolerance of 1, and :start? set to true" do
+      Puppet.settings.expects(:value).with(:runinterval).returns 5
+      timer = stub 'timer', :sound_alarm => nil
+      EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1).returns timer
+
+      @agent.stubs(:run)
+      @agent.start
+    end
+
+    it "should run once immediately" do
+      timer = mock 'timer'
+      EventLoop::Timer.expects(:new).returns timer
+
+      timer.expects(:sound_alarm)
+
+      @agent.start
+    end
+
+    it "should run within the block passed to the timer" do
+      timer = stub 'timer', :sound_alarm => nil
+      EventLoop::Timer.expects(:new).returns(timer).yields
+      @agent.expects(:run)
+
+      @agent.start
+    end
+  end
+end

data/spec/unit/application/agent_spec.rb

@@ -0,0 +1,588 @@
+#!/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
+  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 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 waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
+      Puppet[:onetime] = true
+      Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(0)
+      @puppetd.setup_host
+    end
+
+    it "should use supplied waitforcert when --onetime is specified" do
+      Puppet[:onetime] = true
+      @puppetd.handle_waitforcert(60)
+      Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(60)
+      @puppetd.setup_host
+    end
+
+    it "should use a default value for waitforcert when --onetime and --waitforcert are not specified" do
+      Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(120)
+      @puppetd.setup_host
+    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 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
+    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