puppet 3.2.4 → 3.3.0.rc2

data/spec/integration/parser/catalog_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'matchers/include_in_order'
+require 'puppet_spec/compiler'
+require 'puppet/indirector/catalog/compiler'
+
+describe "Transmission of the catalog to the agent" do
+  include PuppetSpec::Compiler
+
+  it "preserves the order in which the resources are added to the catalog" do
+    resources_in_declaration_order = ["Class[First]",
+                                      "Second[position]",
+                                      "Class[Third]",
+                                      "Fourth[position]"]
+
+    master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
+      define fourth() { }
+      class third { }
+
+      define second() {
+        fourth { "position": }
+      }
+
+      class first {
+        second { "position": }
+        class { "third": }
+      }
+
+      include first
+    EOM
+
+    expect(resources_in(master_catalog)).
+      to include_in_order(*resources_in_declaration_order)
+    expect(resources_in(agent_catalog)).
+      to include_in_order(*resources_in_declaration_order)
+  end
+
+  it "does not contain unrealized, virtual resources" do
+    virtual_resources = ["Unrealized[unreal]", "Class[Unreal]"]
+
+    master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
+      class unreal { }
+      define unrealized() { }
+
+      class real {
+        @unrealized { "unreal": }
+        @class { "unreal": }
+      }
+
+      include real
+    EOM
+
+    expect(resources_in(master_catalog)).to_not include(*virtual_resources)
+    expect(resources_in(agent_catalog)).to_not include(*virtual_resources)
+  end
+
+  it "does not contain unrealized, exported resources" do
+    exported_resources = ["Unrealized[unreal]", "Class[Unreal]"]
+
+    master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
+      class unreal { }
+      define unrealized() { }
+
+      class real {
+        @@unrealized { "unreal": }
+        @@class { "unreal": }
+      }
+
+      include real
+    EOM
+
+    expect(resources_in(master_catalog)).to_not include(*exported_resources)
+    expect(resources_in(agent_catalog)).to_not include(*exported_resources)
+  end
+
+  def master_and_agent_catalogs_for(manifest)
+    master_catalog = Puppet::Resource::Catalog::Compiler.new.filter(compile_to_catalog(manifest))
+    agent_catalog = Puppet::Resource::Catalog.convert_from(:pson, master_catalog.render(:pson))
+
+    [master_catalog, agent_catalog]
+  end
+
+  def resources_in(catalog)
+    catalog.resources.map(&:ref)
+  end
+end

data/spec/integration/provider/cron/crontab_spec.rb

@@ -160,6 +160,17 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         run_in_catalog(resource)
         expect_output('modify_entry')
       end
+      it "should change a special schedule to numeric if requested" do
+        resource = Puppet::Type.type(:cron).new(
+          :name        => 'My daily failure',
+          :special     => 'absent',
+          :command     => '/bin/false',
+          :target      => crontab_user1,
+          :user        => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('unspecialized')
+      end
       it "should not try to move an entry from one file to another" do
         # force the parsedfile provider to also parse user1's crontab
         random_resource = Puppet::Type.type(:cron).new(

data/spec/integration/provider/mount_spec.rb

@@ -20,6 +20,7 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
     @current_options = "local"
     @current_device = "/dev/disk1s1"
     Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
+    Facter.stubs(:value).with(:kernel).returns('Darwin')
     Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
     Facter.stubs(:value).with(:osfamily).returns('Darwin')
     Puppet::Util::ExecutionStub.set do |command, options|

data/spec/integration/transaction_spec.rb

@@ -33,7 +33,7 @@ describe Puppet::Transaction do
 
     resource.expects(:eval_generate).returns([child_resource])
 
-    transaction = Puppet::Transaction.new(catalog)
+    transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
 
     resource.expects(:retrieve).raises "this is a failure"
     resource.stubs(:err)
@@ -49,7 +49,7 @@ describe Puppet::Transaction do
     resource.virtual = true
     catalog.add_resource resource
 
-    transaction = Puppet::Transaction.new(catalog)
+    transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
 
     resource.expects(:evaluate).never
 
@@ -74,7 +74,7 @@ describe Puppet::Transaction do
     resource.virtual = true
     catalog.add_resource resource
 
-    transaction = Puppet::Transaction.new(catalog)
+    transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
 
     resource.expects(:evaluate).never
 
@@ -86,7 +86,7 @@ describe Puppet::Transaction do
     resource = Puppet::Type.type(:interface).new :name => "FastEthernet 0/1"
     catalog.add_resource resource
 
-    transaction = Puppet::Transaction.new(catalog)
+    transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
     transaction.for_network_device = false
 
     transaction.expects(:apply).never.with(resource, nil)
@@ -100,7 +100,7 @@ describe Puppet::Transaction do
     resource = Puppet::Type.type(:file).new :path => make_absolute("/foo/bar"), :backup => false
     catalog.add_resource resource
 
-    transaction = Puppet::Transaction.new(catalog)
+    transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
     transaction.for_network_device = true
 
     transaction.expects(:apply).never.with(resource, nil)
@@ -114,7 +114,7 @@ describe Puppet::Transaction do
     resource = Puppet::Type.type(:interface).new :name => "FastEthernet 0/1"
     catalog.add_resource resource
 
-    transaction = Puppet::Transaction.new(catalog)
+    transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
     transaction.for_network_device = true
 
     transaction.expects(:apply).with(resource, nil)
@@ -128,7 +128,7 @@ describe Puppet::Transaction do
     resource = Puppet::Type.type(:schedule).new :name => "test"
     catalog.add_resource resource
 
-    transaction = Puppet::Transaction.new(catalog)
+    transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
     transaction.for_network_device = true
 
     transaction.expects(:apply).with(resource, nil)
@@ -341,6 +341,6 @@ describe Puppet::Transaction do
 
     trans = catalog.apply
 
-    trans.resource_harness.should be_scheduled(trans.resource_status(resource), resource)
+    trans.resource_harness.should be_scheduled(resource)
   end
 end

data/spec/integration/type/file_spec.rb

@@ -454,7 +454,7 @@ describe Puppet::Type.type(:file) do
       catalog.apply
 
       File.readlink(link).should == dest2
-      Find.find(bucket[:path]) { |f| File.file?(f) }.should be_nil
+      File.exist?(bucket[:path]).should be_false
     end
 
     it "should backup directories to the local filesystem by copying the whole directory" do

data/spec/integration/util/settings_spec.rb

@@ -10,23 +10,27 @@ describe Puppet::Settings do
     { :noop => {:default => false, :desc => "noop"} }
   end
 
+  def define_settings(section, settings_hash)
+    settings.define_settings(section, minimal_default_settings.update(settings_hash))
+  end
+
+  let(:settings) { Puppet::Settings.new }
+
   it "should be able to make needed directories" do
-    settings = Puppet::Settings.new
-    settings.define_settings :main, minimal_default_settings.update(
-        :maindir => {
-            :default => tmpfile("main"),
-            :type => :directory,
-            :desc => "a",
-        }
+    define_settings(:main,
+      :maindir => {
+          :default => tmpfile("main"),
+          :type => :directory,
+          :desc => "a",
+      }
     )
     settings.use(:main)
 
-    File.should be_directory(settings[:maindir])
+    expect(File.directory?(settings[:maindir])).to be_true
   end
 
   it "should make its directories with the correct modes" do
-    settings = Puppet::Settings.new
-    settings.define_settings :main,  minimal_default_settings.update(
+    define_settings(:main,
         :maindir => {
             :default => tmpfile("main"),
             :type => :directory,
@@ -37,6 +41,49 @@ describe Puppet::Settings do
 
     settings.use(:main)
 
-    (File.stat(settings[:maindir]).mode & 007777).should == (Puppet.features.microsoft_windows? ? 0755 : 0750)
+    expect(File.stat(settings[:maindir]).mode & 007777).to eq(Puppet.features.microsoft_windows? ? 0755 : 0750)
+  end
+
+  it "reparses configuration if configuration file is touched", :if => !Puppet.features.microsoft_windows? do
+    config = tmpfile("config")
+    define_settings(:main,
+      :config => {
+        :type => :file,
+        :default => config,
+        :desc => "a"
+      },
+      :environment => {
+        :default => 'dingos',
+        :desc => 'test',
+      }
+    )
+
+    Puppet[:filetimeout] = '1s'
+
+    File.open(config, 'w') do |file|
+      file.puts <<-EOF
+[main]
+environment=toast
+      EOF
+    end
+
+    settings.initialize_global_settings
+    expect(settings[:environment]).to eq('toast')
+
+    # First reparse establishes WatchedFiles
+    settings.reparse_config_files
+
+    sleep 1
+
+    File.open(config, 'w') do |file|
+      file.puts <<-EOF
+[main]
+environment=bacon
+      EOF
+    end
+
+    # Second reparse if later than filetimeout, reparses if changed
+    settings.reparse_config_files
+    expect(settings[:environment]).to eq('bacon')
   end
 end

data/spec/lib/matchers/include_in_order.rb

@@ -0,0 +1,21 @@
+RSpec::Matchers.define :include_in_order do |*expected|
+  include RSpec::Matchers::Pretty
+
+  match do |actual|
+    elements = expected.dup
+    actual.each do |elt|
+      if elt == elements.first
+        elements.shift
+      end
+    end
+    elements.empty?
+  end
+
+  def failure_message_for_should
+    "expected #{@actual.inspect} to include#{expected_to_sentence} in order"
+  end
+
+  def failure_message_for_should_not
+    "expected #{@actual.inspect} not to include#{expected_to_sentence} in order"
+  end
+end

data/spec/lib/matchers/include_in_order_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'matchers/include_in_order'
+
+describe "Matching whether elements are included in order" do
+  context "an empty array" do
+    it "is included in an empty array" do
+      expect([]).to include_in_order()
+    end
+
+    it "is included in a non-empty array" do
+      expect([1]).to include_in_order()
+    end
+  end
+
+  it "[1,2,3] is included in [0,1,2,3,4]" do
+    expect([0,1,2,3,4]).to include_in_order(1,2,3)
+  end
+
+  it "[2,1] is not included in order in [1,2]" do
+    expect([1,2]).not_to include_in_order(2,1)
+  end
+
+  it "[2,4,6] is included in order in [1,2,3,4,5,6]" do
+    expect([1,2,3,4,5,6]).to include_in_order(2,4,6)
+  end
+
+  it "overlapping ordered array is not included" do
+    expect([1,2,3]).not_to include_in_order(2,3,4)
+  end
+end

data/spec/lib/matchers/relationship_graph_matchers.rb

@@ -0,0 +1,48 @@
+module RelationshipGraphMatchers
+  class EnforceOrderWithEdge
+    def initialize(before, after)
+      @before = before
+      @after = after
+    end
+
+    def matches?(actual_graph)
+      @actual_graph = actual_graph
+
+      @reverse_edge = actual_graph.edge?(
+          vertex_called(actual_graph, @after),
+          vertex_called(actual_graph, @before))
+
+      @forward_edge = actual_graph.edge?(
+          vertex_called(actual_graph, @before),
+          vertex_called(actual_graph, @after))
+
+      @forward_edge && !@reverse_edge
+    end
+
+    def failure_message_for_should
+      "expect #{@actual_graph.to_dot_graph} to only contain an edge from #{@before} to #{@after} but #{[forward_failure_message, reverse_failure_message].compact.join(' and ')}"
+    end
+
+    def forward_failure_message
+      if !@forward_edge
+        "did not contain an edge from #{@before} to #{@after}"
+      end
+    end
+
+    def reverse_failure_message
+      if @reverse_edge
+        "contained an edge from #{@after} to #{@before}"
+      end
+    end
+
+    private
+
+    def vertex_called(graph, name)
+      graph.vertices.find { |v| v.ref =~ /#{Regexp.escape(name)}/ }
+    end
+  end
+
+  def enforce_order_with_edge(before, after)
+    EnforceOrderWithEdge.new(before, after)
+  end
+end

data/spec/lib/puppet_spec/compiler.rb

@@ -3,4 +3,28 @@ module PuppetSpec::Compiler
     Puppet[:code] = string
     Puppet::Parser::Compiler.compile(node)
   end
+
+  def compile_to_ral(manifest)
+    catalog = compile_to_catalog(manifest)
+    ral = catalog.to_ral
+    ral.finalize
+    ral
+  end
+
+  def compile_to_relationship_graph(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
+    ral = compile_to_ral(manifest)
+    graph = Puppet::Graph::RelationshipGraph.new(prioritizer)
+    graph.populate_from(ral)
+    graph
+  end
+
+  def apply_compiled_manifest(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
+    transaction = Puppet::Transaction.new(compile_to_ral(manifest),
+                                         Puppet::Transaction::Report.new("apply"),
+                                         prioritizer)
+    transaction.evaluate
+    transaction.report.finalize_report
+
+    transaction
+  end
 end

data/spec/lib/puppet_spec/pops.rb

@@ -0,0 +1,16 @@
+module PuppetSpec::Pops
+  extend RSpec::Matchers::DSL
+
+  # Checks if an Acceptor has a specific issue in its list of diagnostics
+  matcher :have_issue do |expected|
+    match do |actual|
+      actual.diagnostics.index { |i| i.issue == expected } != nil
+    end
+    failure_message_for_should do |actual|
+      "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to contain issue #{expected.issue_code}"
+    end
+    failure_message_for_should_not do |actual|
+      "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to not contain issue #{expected.issue_code}"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -33,7 +33,6 @@ require 'puppet_spec/fixtures'
 require 'puppet_spec/matchers'
 require 'puppet_spec/database'
 require 'monkey_patches/alias_should_to_must'
-require 'monkey_patches/publicize_methods'
 require 'puppet/test/test_helper'
 
 Pathname.glob("#{dir}/shared_contexts/*.rb") do |file|

data/spec/unit/application/agent_spec.rb

@@ -11,18 +11,28 @@ describe Puppet::Application::Agent do
 
   before :each do
     @puppetd = Puppet::Application[:agent]
-    @puppetd.stubs(:puts)
-    @daemon = stub_everything 'daemon'
+
+    @daemon = Puppet::Daemon.new(nil)
+    @daemon.stubs(:daemonize)
+    @daemon.stubs(:start)
+    @daemon.stubs(:stop)
     Puppet::Daemon.stubs(:new).returns(@daemon)
     Puppet[:daemonize] = false
+
     @agent = stub_everything 'agent'
     Puppet::Agent.stubs(:new).returns(@agent)
+
     @puppetd.preinit
     Puppet::Util::Log.stubs(:newdestination)
 
+    @ssl_host = stub_everything 'ssl host'
+    Puppet::SSL::Host.stubs(:new).returns(@ssl_host)
+
     Puppet::Node.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
     Puppet::Node::Facts.indirection.stubs(:terminus_class=)
+
+    $stderr.expects(:puts).never
   end
 
   it "should operate in agent run_mode" do
@@ -94,75 +104,80 @@ describe Puppet::Application::Agent do
       @puppetd.command_line.stubs(:args).returns([])
     end
 
-    [:centrallogging, :enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
+    [: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')
+
+        @puppetd.options[option].should == 'arg'
       end
     end
 
     describe "when handling --disable" do
-      it "should declare handle_disable method" do
-        @puppetd.should respond_to(:handle_disable)
-      end
-
       it "should set disable to true" do
-        @puppetd.options.stubs(:[]=)
-        @puppetd.options.expects(:[]=).with(:disable, true)
         @puppetd.handle_disable('')
+
+        @puppetd.options[:disable].should == true
       end
 
       it "should store disable message" do
-        @puppetd.options.stubs(:[]=)
-        @puppetd.options.expects(:[]=).with(:disable_message, "message")
         @puppetd.handle_disable('message')
+
+        @puppetd.options[:disable_message].should == 'message'
       end
     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
+      @agent.stubs(:run).returns(2)
       Puppet[:onetime] = true
-      Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(0)
-      @puppetd.setup_host
+
+      @ssl_host.expects(:wait_for_cert).with(0)
+
+      expect { execute_agent }.to exit_with 0
     end
 
     it "should use supplied waitforcert when --onetime is specified" do
+      @agent.stubs(:run).returns(2)
       Puppet[:onetime] = true
       @puppetd.handle_waitforcert(60)
-      Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(60)
-      @puppetd.setup_host
+
+      @ssl_host.expects(:wait_for_cert).with(60)
+
+      expect { execute_agent }.to exit_with 0
     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
+      @ssl_host.expects(:wait_for_cert).with(120)
+
+      execute_agent
     end
 
     it "should use the waitforcert setting when checking for a signed certificate" do
       Puppet[:waitforcert] = 10
-      Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(10)
-      @puppetd.setup_host
+      @ssl_host.expects(:wait_for_cert).with(10)
+
+      execute_agent
     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")
+
+      @puppetd.options[:setdest].should == true
     end
 
     it "should parse the log destination from the command line" do
@@ -174,50 +189,37 @@ describe Puppet::Application::Agent do
     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"
+      @puppetd.options[:waitforcert].should == 42
     end
-
   end
 
   describe "during setup" do
     before :each do
-      @puppetd.options.stubs(:[])
       Puppet.stubs(:info)
       FileTest.stubs(:exists?).returns(true)
       Puppet[:libdir] = "/dev/null/lib"
-      Puppet::SSL::Host.stubs(:ca_location=)
       Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
       Puppet::Transaction::Report.indirection.stubs(:cache_class=)
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
       Puppet::Resource::Catalog.indirection.stubs(:cache_class=)
       Puppet::Node::Facts.indirection.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.options[:test] = 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
+
+        @puppetd.options[:verbose].should == true
       end
       it "should set options[:onetime] to true" do
         Puppet[:onetime] = false
@@ -225,8 +227,9 @@ describe Puppet::Application::Agent do
         Puppet[:onetime].should == true
       end
       it "should set options[:detailed_exitcodes] to true" do
-        @puppetd.options.expects(:[]=).with(:detailed_exitcodes,true)
         @puppetd.setup_test
+
+        @puppetd.options[:detailed_exitcodes].should == true
       end
     end
 
@@ -241,29 +244,30 @@ describe Puppet::Application::Agent do
       end
 
       it "should set log level to debug if --debug was passed" do
-        @puppetd.options.stubs(:[]).with(:debug).returns(true)
+        @puppetd.options[:debug] = true
         @puppetd.setup_logs
         Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose was passed" do
-        @puppetd.options.stubs(:[]).with(:verbose).returns(true)
+        @puppetd.options[:verbose] = true
         @puppetd.setup_logs
         Puppet::Util::Log.level.should == :info
       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)
+          @puppetd.options[level] = true
 
-          Puppet::Util::Log.expects(:newdestination).with(:console)
+          Puppet::Util::Log.expects(:newdestination).at_least_once
+          Puppet::Util::Log.expects(:newdestination).with(:console).once
 
           @puppetd.setup_logs
         end
       end
 
       it "should set a default log destination if no --logdest" do
-        @puppetd.options.stubs(:[]).with(:setdest).returns(false)
+        @puppetd.options[:setdest] = false
 
         Puppet::Util::Log.expects(:setup_default)
 
@@ -275,7 +279,7 @@ describe Puppet::Application::Agent do
     it "should print puppet config if asked to in Puppet config" do
       Puppet[:configprint] = "pluginsync"
       Puppet.settings.expects(:print_configs).returns true
-      expect { @puppetd.setup }.to exit_with 0
+      expect { execute_agent }.to exit_with 0
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
@@ -283,17 +287,7 @@ describe Puppet::Application::Agent do
       Puppet[:modulepath] = path
       Puppet[:configprint] = "modulepath"
       Puppet::Settings.any_instance.expects(:puts).with(path)
-      expect { @puppetd.setup }.to exit_with 0
-    end
-
-    it "should set a central log destination with --centrallogs" do
-      @puppetd.options.stubs(:[]).with(:centrallogs).returns(true)
-      Puppet[:server] = "puppet.reductivelabs.com"
-      Puppet::Util::Log.stubs(:setup_default)
-
-      Puppet::Util::Log.expects(:newdestination).with("puppet.reductivelabs.com")
-
-      @puppetd.setup
+      expect { execute_agent }.to exit_with 0
     end
 
     it "should use :main, :puppetd, and :ssl" do
@@ -309,7 +303,7 @@ describe Puppet::Application::Agent do
     end
 
     it "should install a none ca location in fingerprint mode" do
-      @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
+      @puppetd.options[:fingerprint] = true
       Puppet::SSL::Host.expects(:ca_location=).with(:none)
 
       @puppetd.setup
@@ -373,7 +367,7 @@ describe Puppet::Application::Agent do
 
     [: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.options[action] = true
         @puppetd.expects(:enable_disable_client).with(@agent)
 
         @puppetd.setup
@@ -383,41 +377,43 @@ describe Puppet::Application::Agent do
     describe "when enabling or disabling agent" do
       [:enable, :disable].each do |action|
         it "should call client.#{action}" do
-          @puppetd.options.stubs(:[]).with(action).returns(true)
+          @puppetd.options[action] = true
           @agent.expects(action)
-          expect { @puppetd.enable_disable_client(@agent) }.to exit_with 0
+          expect { execute_agent }.to exit_with 0
         end
       end
 
       it "should pass the disable message when disabling" do
-        @puppetd.options.stubs(:[]).with(:disable).returns(true)
-        @puppetd.options.stubs(:[]).with(:disable_message).returns("message")
+        @puppetd.options[:disable] = true
+        @puppetd.options[:disable_message] = "message"
         @agent.expects(:disable).with("message")
-        expect { @puppetd.enable_disable_client(@agent) }.to exit_with 0
+
+        expect { execute_agent }.to exit_with 0
       end
 
       it "should pass the default disable message when disabling without a message" do
-        @puppetd.options.stubs(:[]).with(:disable).returns(true)
-        @puppetd.options.stubs(:[]).with(:disable_message).returns(nil)
+        @puppetd.options[:disable] = true
+        @puppetd.options[:disable_message] = nil
         @agent.expects(:disable).with("reason not specified")
-        expect { @puppetd.enable_disable_client(@agent) }.to exit_with 0
-      end
 
-      it "should finally exit" do
-        expect { @puppetd.enable_disable_client(@agent) }.to exit_with 0
+        expect { execute_agent }.to exit_with 0
       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
+      @puppetd.options[:client] = true
+
+      execute_agent
+
+      @daemon.agent.should == @agent
     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
+
+      execute_agent
+
+      @daemon.agent.should be_nil
     end
 
     it "should daemonize if needed" do
@@ -426,66 +422,72 @@ describe Puppet::Application::Agent do
 
       @daemon.expects(:daemonize)
 
-      @puppetd.setup
+      execute_agent
     end
 
     it "should wait for a certificate" do
-      @puppetd.options.stubs(:[]).with(:waitforcert).returns(123)
-      @host.expects(:wait_for_cert).with(123)
+      @puppetd.options[:waitforcert] = 123
+      @ssl_host.expects(:wait_for_cert).with(123)
 
-      @puppetd.setup
+      execute_agent
     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
+      @puppetd.options[:fingerprint] = true
+      @puppetd.options[:waitforcert] = 123
+      @puppetd.options[:digest] = 'MD5'
 
-    it "should setup listen if told to and not onetime" do
-      Puppet[:listen] = true
-      @puppetd.options.stubs(:[]).with(:onetime).returns(false)
+      certificate = mock 'certificate'
+      certificate.stubs(:digest).with('MD5').returns('ABCDE')
+      @ssl_host.stubs(:certificate).returns(certificate)
 
-      @puppetd.expects(:setup_listen)
+      @ssl_host.expects(:wait_for_cert).never
+      @puppetd.expects(:puts).with('ABCDE')
 
-      @puppetd.setup
+      execute_agent
     end
 
     describe "when setting up listen" do
       before :each do
         FileTest.stubs(:exists?).with('auth').returns(true)
         File.stubs(:exist?).returns(true)
-        @puppetd.options.stubs(:[]).with(:serve).returns([])
+        @puppetd.options[:serve] = []
         @server = stub_everything 'server'
         Puppet::Network::Server.stubs(:new).returns(@server)
       end
 
 
       it "should exit if no authorization file" do
+        Puppet[:listen] = true
         Puppet.stubs(:err)
         FileTest.stubs(:exists?).with(Puppet[:rest_authconfig]).returns(false)
-        expect { @puppetd.setup_listen }.to exit_with 14
+
+        expect do
+          execute_agent
+        end.to exit_with 14
       end
 
       it "should use puppet default port" do
         Puppet[:puppetport] = 32768
+        Puppet[:listen] = true
 
         Puppet::Network::Server.expects(:new).with(anything, 32768)
 
-        @puppetd.setup_listen
+        execute_agent
       end
-      
+
       it "should issue a warning that listen is deprecated" do
+        Puppet[:listen] = true
+
         Puppet.expects(:warning).with() { |msg| msg =~ /kick is deprecated/ }
-        @puppetd.setup_listen
+
+        execute_agent
       end
     end
 
     describe "when setting up for fingerprint" do
       before(:each) do
-        @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
+        @puppetd.options[:fingerprint] = true
       end
 
       it "should not setup as an agent" do
@@ -502,11 +504,6 @@ describe Puppet::Application::Agent do
         @daemon.expects(:daemonize).never
         @puppetd.setup
       end
-
-      it "should setup our certificate host" do
-        @puppetd.expects(:setup_host)
-        @puppetd.setup
-      end
     end
 
     describe "when configuring agent for catalog run" do
@@ -526,114 +523,112 @@ describe Puppet::Application::Agent do
 
   describe "when running" do
     before :each do
-      @puppetd.agent = @agent
-      @puppetd.daemon = @daemon
-      @puppetd.options.stubs(:[]).with(:fingerprint).returns(false)
+      @puppetd.options[:fingerprint] = false
     end
 
     it "should dispatch to fingerprint if --fingerprint is used" do
-      @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
+      @puppetd.options[:fingerprint] = true
 
       @puppetd.stubs(:fingerprint)
-      @puppetd.run_command
+
+      execute_agent
     end
 
     it "should dispatch to onetime if --onetime is used" do
-      @puppetd.options.stubs(:[]).with(:onetime).returns(true)
+      @puppetd.options[:onetime] = true
 
       @puppetd.stubs(:onetime)
-      @puppetd.run_command
+
+      execute_agent
     end
 
     it "should dispatch to main if --onetime and --fingerprint are not used" do
-      @puppetd.options.stubs(:[]).with(:onetime).returns(false)
+      @puppetd.options[:onetime] = false
 
       @puppetd.stubs(:main)
-      @puppetd.run_command
+
+      execute_agent
     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)
+        Puppet[:onetime] = true
+        @puppetd.options[:client] = :client
+        @puppetd.options[:detailed_exitcodes] = false
         Puppet.stubs(:newservice)
       end
 
       it "should exit if no defined --client" do
-        $stderr.stubs(:puts)
-        @puppetd.options.stubs(:[]).with(:client).returns(nil)
-        expect { @puppetd.onetime }.to exit_with 43
+        @puppetd.options[:client] = nil
+
+        Puppet.expects(:err).with('onetime is specified but there is no client')
+
+        expect { execute_agent }.to exit_with 43
       end
 
       it "should setup traps" do
         @daemon.expects(:set_signal_traps)
-        expect { @puppetd.onetime }.to exit_with 0
+
+        expect { execute_agent }.to exit_with 0
       end
 
       it "should let the agent run" do
         @agent.expects(:run).returns(:report)
-        expect { @puppetd.onetime }.to exit_with 0
-      end
 
-      it "should finish by exiting with 0 error code" do
-        expect { @puppetd.onetime }.to exit_with 0
+        expect { execute_agent }.to exit_with 0
       end
 
       it "should stop the daemon" do
         @daemon.expects(:stop).with(:exit => false)
-        expect { @puppetd.onetime }.to exit_with 0
+
+        expect { execute_agent }.to exit_with 0
       end
 
       describe "and --detailed-exitcodes" do
         before :each do
-          @puppetd.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+          @puppetd.options[:detailed_exitcodes] = true
         end
 
         it "should exit with agent computed exit status" do
           Puppet[:noop] = false
           @agent.stubs(:run).returns(666)
 
-          expect { @puppetd.onetime }.to exit_with 666
+          expect { execute_agent }.to exit_with 666
         end
 
         it "should exit with the agent's exit status, even if --noop is set." do
           Puppet[:noop] = true
           @agent.stubs(:run).returns(666)
 
-          expect { @puppetd.onetime }.to exit_with 666
+          expect { execute_agent }.to exit_with 666
         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)
+        @cert = mock 'cert'
+        @puppetd.options[:fingerprint] = true
+        @puppetd.options[:digest] = :MD5
       end
 
       it "should fingerprint the certificate if it exists" do
-        @host.expects(:certificate).returns(@cert)
-        @cert.expects(:digest).with('MD5').returns "fingerprint"
-        @puppetd.fingerprint
-      end
+        @ssl_host.stubs(:certificate).returns(@cert)
+        @cert.stubs(:digest).with('MD5').returns "fingerprint"
+
+        @puppetd.expects(:puts).with "fingerprint"
 
-      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(:digest).with('MD5').returns "fingerprint"
         @puppetd.fingerprint
       end
 
-      it "should display the fingerprint" do
-        @host.stubs(:certificate).returns(@cert)
-        @cert.stubs(:digest).with('MD5').returns("DIGEST")
+      it "should fingerprint the certificate request if no certificate have been signed" do
+        @ssl_host.stubs(:certificate).returns(nil)
+        @ssl_host.stubs(:certificate_request).returns(@cert)
+        @cert.stubs(:digest).with('MD5').returns "fingerprint"
 
-        @puppetd.expects(:puts).with "DIGEST"
+        @puppetd.expects(:puts).with "fingerprint"
 
         @puppetd.fingerprint
       end
@@ -642,14 +637,19 @@ describe Puppet::Application::Agent do
     describe "without --onetime and --fingerprint" do
       before :each do
         Puppet.stubs(:notice)
-        @puppetd.options.stubs(:[]).with(:client)
+        @puppetd.options[:client] = nil
       end
 
       it "should start our daemon" do
         @daemon.expects(:start)
 
-        @puppetd.main
+        execute_agent
       end
     end
   end
+
+  def execute_agent
+    @puppetd.setup
+    @puppetd.run_command
+  end
 end