diff --git a/lib/puppet/application/face_base.rb b/lib/puppet/application/face_base.rb
index 9da48af55..7bebd18bb 100644
--- a/lib/puppet/application/face_base.rb
+++ b/lib/puppet/application/face_base.rb
@@ -1,199 +1,216 @@
 require 'puppet/application'
 require 'puppet/face'
 require 'optparse'
 require 'pp'
 
 class Puppet::Application::FaceBase < Puppet::Application
   should_parse_config
   run_mode :agent
 
   option("--debug", "-d") do |arg|
     Puppet::Util::Log.level = :debug
   end
 
   option("--verbose", "-v") do
     Puppet::Util::Log.level = :info
   end
 
   option("--render-as FORMAT") do |arg|
     @render_as = arg.to_sym
   end
 
   option("--mode RUNMODE", "-r") do |arg|
     raise "Invalid run mode #{arg}; supported modes are user, agent, master" unless %w{user agent master}.include?(arg)
     self.class.run_mode(arg.to_sym)
     set_run_mode self.class.run_mode
   end
 
 
   attr_accessor :face, :action, :type, :arguments, :render_as
   attr_writer :exit_code
 
   # This allows you to set the exit code if you don't want to just exit
   # immediately but you need to indicate a failure.
   def exit_code
     @exit_code || 0
   end
 
   def render(result)
     format = render_as || action.render_as || :for_humans
 
     # Invoke the rendering hook supplied by the user, if appropriate.
     if hook = action.when_rendering(format) then
       result = hook.call(result)
     end
 
     if format == :for_humans then
       render_for_humans(result)
     else
       render_method = Puppet::Network::FormatHandler.format(format).render_method
       if render_method == "to_pson"
         PSON::pretty_generate(result, :allow_nan => true, :max_nesting => false)
       else
         result.send(render_method)
       end
     end
   end
 
   def render_for_humans(result)
     # String to String
     return result if result.is_a? String
     return result if result.is_a? Numeric
 
     # Simple hash to table
     if result.is_a? Hash and result.keys.all? { |x| x.is_a? String or x.is_a? Numeric }
       output = ''
       column_a = result.map do |k,v| k.to_s.length end.max + 2
       column_b = 79 - column_a
       result.sort_by { |k,v| k.to_s } .each do |key, value|
         output << key.to_s.ljust(column_a)
         output << PP.pp(value, '', column_b).
           chomp.gsub(/\n */) { |x| x + (' ' * column_a) }
         output << "\n"
       end
       return output
     end
 
     # ...or pretty-print the inspect outcome.
     return result.pretty_inspect
   end
 
   def preinit
     super
     Signal.trap(:INT) do
       $stderr.puts "Cancelling Face"
       exit(0)
     end
   end
 
   def parse_options
     # We need to parse enough of the command line out early, to identify what
     # the action is, so that we can obtain the full set of options to parse.
 
     # REVISIT: These should be configurable versions, through a global
     # '--version' option, but we don't implement that yet... --daniel 2011-03-29
-    @type      = self.class.name.to_s.sub(/.+:/, '').downcase.to_sym
-    @face      = Puppet::Face[@type, :current]
+    @type = self.class.name.to_s.sub(/.+:/, '').downcase.to_sym
+    @face = Puppet::Face[@type, :current]
 
     # Now, walk the command line and identify the action.  We skip over
     # arguments based on introspecting the action and all, and find the first
     # non-option word to use as the action.
     action = nil
     index  = -1
     until @action or (index += 1) >= command_line.args.length do
       item = command_line.args[index]
       if item =~ /^-/ then
         option = @face.options.find do |name|
           item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
         end
         if option then
           option = @face.get_option(option)
           # If we have an inline argument, just carry on.  We don't need to
           # care about optional vs mandatory in that case because we do a real
           # parse later, and that will totally take care of raising the error
           # when we get there. --daniel 2011-04-04
           if option.takes_argument? and !item.index('=') then
             index += 1 unless
               (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
           end
         elsif option = find_global_settings_argument(item) then
           unless Puppet.settings.boolean? option.name then
             # As far as I can tell, we treat non-bool options as always having
             # a mandatory argument. --daniel 2011-04-05
             index += 1          # ...so skip the argument.
           end
+        elsif option = find_application_argument(item) then
+          index += 1 if (option[:argument] and option[:optional])
         else
           raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
         end
       else
         @action = @face.get_action(item.to_sym)
       end
     end
 
     if @action.nil?
       @action = @face.get_default_action()
       @is_default_action = true
     end
 
     # Now we can interact with the default option code to build behaviour
     # around the full set of options we now know we support.
     @action.options.each do |option|
       option = @action.get_option(option) # make it the object.
       self.class.option(*option.optparse) # ...and make the CLI parse it.
     end if @action
 
     # ...and invoke our parent to parse all the command line options.
     super
   end
 
   def find_global_settings_argument(item)
     Puppet.settings.each do |name, object|
       object.optparse_args.each do |arg|
         next unless arg =~ /^-/
         # sadly, we have to emulate some of optparse here...
         pattern = /^#{arg.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         pattern.match item and return object
       end
     end
     return nil                  # nothing found.
   end
 
+  def find_application_argument(item)
+    self.class.option_parser_commands.each do |options, function|
+      options.each do |option|
+        next unless option =~ /^-/
+        pattern = /^#{option.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
+        next unless pattern.match(item)
+        return {
+          :argument => option =~ /[ =]/,
+          :optional => option =~ /[ =]\[/
+        }
+      end
+    end
+    return nil                  # not found
+  end
+
   def setup
     Puppet::Util::Log.newdestination :console
 
     @arguments = command_line.args
 
     # Note: because of our definition of where the action is set, we end up
     # with it *always* being the first word of the remaining set of command
     # line arguments.  So, strip that off when we construct the arguments to
     # pass down to the face action. --daniel 2011-04-04
     # Of course, now that we have default actions, we should leave the
     # "action" name on if we didn't actually consume it when we found our
     # action.
     @arguments.delete_at(0) unless @is_default_action
 
     # We copy all of the app options to the end of the call; This allows each
     # action to read in the options.  This replaces the older model where we
     # would invoke the action with options set as global state in the
     # interface object.  --daniel 2011-03-28
     @arguments << options
   end
 
 
   def main
     # Call the method associated with the provided action (e.g., 'find').
     if @action
       result = @face.send(@action.name, *arguments)
       puts render(result) unless result.nil?
     else
       if arguments.first.is_a? Hash
         puts "#{@face} does not have a default action"
       else
         puts "#{@face} does not respond to action #{arguments.first}"
       end
 
       puts Puppet::Face[:help, :current].help(@face.name, *arguments)
     end
     exit(exit_code)
   end
 end
diff --git a/lib/puppet/faces/help/action.erb b/lib/puppet/faces/help/action.erb
deleted file mode 100644
index eaf131464..000000000
--- a/lib/puppet/faces/help/action.erb
+++ /dev/null
@@ -1,3 +0,0 @@
-Use: puppet <%= face.name %> [options] <%= action.name %> [options]
-
-Summary: <%= action.summary %>
diff --git a/lib/puppet/faces/help/face.erb b/lib/puppet/faces/help/face.erb
deleted file mode 100644
index efe5fd809..000000000
--- a/lib/puppet/faces/help/face.erb
+++ /dev/null
@@ -1,7 +0,0 @@
-Use: puppet <%= face.name %> [options] <action> [options]
-
-Available actions:
-% face.actions.each do |actionname|
-%   action = face.get_action(actionname)
-  <%= action.name.to_s.ljust(16) %>  <%= action.summary %>
-% end
diff --git a/lib/puppet/faces/help/global.erb b/lib/puppet/faces/help/global.erb
deleted file mode 100644
index e123367a2..000000000
--- a/lib/puppet/faces/help/global.erb
+++ /dev/null
@@ -1,20 +0,0 @@
-puppet <subcommand> [options] <action> [options]
-
-Available subcommands, from Puppet Faces:
-% Puppet::Faces.faces.sort.each do |name|
-%   face = Puppet::Faces[name, :current]
-  <%= face.name.to_s.ljust(16) %>  <%= face.summary %>
-% end
-
-% unless legacy_applications.empty? then # great victory when this is true!
-Available applications, soon to be ported to Faces:
-%   legacy_applications.each do |appname|
-%     summary = horribly_extract_summary_from appname
-  <%= appname.to_s.ljust(16) %>  <%= summary %>
-%   end
-% end
-
-See 'puppet help <subcommand> <action>' for help on a specific subcommand action.
-See 'puppet help <subcommand>' for help on a specific subcommand.
-See 'puppet man  <subcommand>' for the full man page.
-Puppet v<%= Puppet::PUPPETVERSION %>
diff --git a/lib/puppet/interface.rb b/lib/puppet/interface.rb
index 5c8ade749..ced00863d 100644
--- a/lib/puppet/interface.rb
+++ b/lib/puppet/interface.rb
@@ -1,160 +1,159 @@
 require 'puppet'
 require 'puppet/util/autoload'
 
 class Puppet::Interface
   require 'puppet/interface/face_collection'
 
   require 'puppet/interface/action_manager'
   include Puppet::Interface::ActionManager
   extend Puppet::Interface::ActionManager
 
   require 'puppet/interface/option_manager'
   include Puppet::Interface::OptionManager
   extend Puppet::Interface::OptionManager
 
   include Puppet::Util
 
   class << self
     # This is just so we can search for actions.  We only use its
     # list of directories to search.
     # Can't we utilize an external autoloader, or simply use the $LOAD_PATH? -pvb
     def autoloader
       @autoloader ||= Puppet::Util::Autoload.new(:application, "puppet/face")
     end
 
     def faces
       Puppet::Interface::FaceCollection.faces
     end
 
-    def face?(name, version)
-      Puppet::Interface::FaceCollection.face?(name, version)
-    end
-
     def register(instance)
       Puppet::Interface::FaceCollection.register(instance)
     end
 
     def define(name, version, &block)
-      if face?(name, version)
-        face = Puppet::Interface::FaceCollection[name, version]
-      else
+      face = Puppet::Interface::FaceCollection[name, version]
+      if face.nil? then
         face = self.new(name, version)
         Puppet::Interface::FaceCollection.register(face)
         # REVISIT: Shouldn't this be delayed until *after* we evaluate the
         # current block, not done before? --daniel 2011-04-07
         face.load_actions
       end
 
       face.instance_eval(&block) if block_given?
 
       return face
     end
 
+    def face?(name, version)
+      Puppet::Interface::FaceCollection[name, version]
+    end
+
     def [](name, version)
       unless face = Puppet::Interface::FaceCollection[name, version]
         if current = Puppet::Interface::FaceCollection[name, :current]
-          raise Puppet::Error, "Could not find version #{version} of #{current}"
+          raise Puppet::Error, "Could not find version #{version} of #{name}"
         else
           raise Puppet::Error, "Could not find Puppet Face #{name.inspect}"
         end
       end
       face
     end
   end
 
   def set_default_format(format)
     Puppet.warning("set_default_format is deprecated (and ineffective); use render_as on your actions instead.")
   end
 
   ########################################################################
   # Documentation.  We currently have to rewrite both getters because we share
   # the same instance between build-time and the runtime instance.  When that
   # splits out this should merge into a module that both the action and face
   # include. --daniel 2011-04-17
   attr_accessor :summary, :description
   def summary(value = nil)
     self.summary = value unless value.nil?
     @summary
   end
   def summary=(value)
     value = value.to_s
     value =~ /\n/ and
       raise ArgumentError, "Face summary should be a single line; put the long text in 'description' instead."
 
     @summary = value
   end
 
   def description(value = nil)
     self.description = value unless value.nil?
     @description
   end
 
 
   ########################################################################
   attr_reader :name, :version
 
   def initialize(name, version, &block)
     unless Puppet::Interface::FaceCollection.validate_version(version)
       raise ArgumentError, "Cannot create face #{name.inspect} with invalid version number '#{version}'!"
     end
 
     @name = Puppet::Interface::FaceCollection.underscorize(name)
     @version = version
 
     instance_eval(&block) if block_given?
   end
 
   # Try to find actions defined in other files.
   def load_actions
     Puppet::Interface.autoloader.search_directories.each do |dir|
       Dir.glob(File.join(dir, "puppet/face/#{name}", "*.rb")).each do |file|
         action = file.sub(dir, '').sub(/^[\\\/]/, '').sub(/\.rb/, '')
         Puppet.debug "Loading action '#{action}' for '#{name}' from '#{dir}/#{action}.rb'"
         require(action)
       end
     end
   end
 
   def to_s
     "Puppet::Face[#{name.inspect}, #{version.inspect}]"
   end
 
   ########################################################################
   # Action decoration, whee!  You are not expected to care about this code,
   # which exists to support face building and construction.  I marked these
   # private because the implementation is crude and ugly, and I don't yet know
   # enough to work out how to make it clean.
   #
   # Once we have established that these methods will likely change radically,
   # to be unrecognizable in the final outcome.  At which point we will throw
   # all this away, replace it with something nice, and work out if we should
   # be making this visible to the outside world... --daniel 2011-04-14
   private
   def __invoke_decorations(type, action, passed_args = [], passed_options = {})
     [:before, :after].member?(type) or fail "unknown decoration type #{type}"
 
     # Collect the decoration methods matching our pass.
     methods = action.options.select do |name|
       passed_options.has_key? name
     end.map do |name|
       action.get_option(name).__decoration_name(type)
     end
 
     methods.each do |hook|
       begin
         respond_to? hook and self.__send__(hook, action, passed_args, passed_options)
       rescue => e
         Puppet.warning("invoking #{action} #{type} hook: #{e}")
       end
     end
   end
 
   def __add_method(name, proc)
     meta_def(name, &proc)
     method(name).unbind
   end
   def self.__add_method(name, proc)
     define_method(name, proc)
     instance_method(name)
   end
 end
diff --git a/lib/puppet/interface/action.rb b/lib/puppet/interface/action.rb
index 23366b407..08bc0a345 100644
--- a/lib/puppet/interface/action.rb
+++ b/lib/puppet/interface/action.rb
@@ -1,231 +1,252 @@
 # -*- coding: utf-8 -*-
 require 'puppet/interface'
 require 'puppet/interface/option'
 
 class Puppet::Interface::Action
   def initialize(face, name, attrs = {})
     raise "#{name.inspect} is an invalid action name" unless name.to_s =~ /^[a-z]\w*$/
     @face    = face
     @name    = name.to_sym
     attrs.each do |k, v| send("#{k}=", v) end
 
     @options        = {}
     @when_rendering = {}
   end
 
   # This is not nice, but it is the easiest way to make us behave like the
   # Ruby Method object rather than UnboundMethod.  Duplication is vaguely
   # annoying, but at least we are a shallow clone. --daniel 2011-04-12
   def __dup_and_rebind_to(to)
     bound_version = self.dup
     bound_version.instance_variable_set(:@face, to)
     return bound_version
   end
 
   def to_s() "#{@face}##{@name}" end
 
   attr_reader   :name
   attr_accessor :default
   def default?
     !!@default
   end
 
   attr_accessor :summary
 
 
   ########################################################################
   # Support for rendering formats and all.
   def when_rendering(type)
     unless type.is_a? Symbol
       raise ArgumentError, "The rendering format must be a symbol, not #{type.class.name}"
     end
     return unless @when_rendering.has_key? type
     return @when_rendering[type].bind(@face)
   end
   def set_rendering_method_for(type, proc)
     unless proc.is_a? Proc
       msg = "The second argument to set_rendering_method_for must be a Proc"
       msg += ", not #{proc.class.name}" unless proc.nil?
       raise ArgumentError, msg
     end
     if proc.arity != 1 then
       msg = "when_rendering methods take one argument, the result, not "
       if proc.arity < 0 then
         msg += "a variable number"
       else
         msg += proc.arity.to_s
       end
       raise ArgumentError, msg
     end
     unless type.is_a? Symbol
       raise ArgumentError, "The rendering format must be a symbol, not #{type.class.name}"
     end
     if @when_rendering.has_key? type then
       raise ArgumentError, "You can't define a rendering method for #{type} twice"
     end
     # Now, the ugly bit.  We add the method to our interface object, and
     # retrieve it, to rotate through the dance of getting a suitable method
     # object out of the whole process. --daniel 2011-04-18
     @when_rendering[type] =
       @face.__send__( :__add_method, __render_method_name_for(type), proc)
   end
 
   def __render_method_name_for(type)
     :"#{name}_when_rendering_#{type}"
   end
   private :__render_method_name_for
 
 
   attr_accessor :render_as
   def render_as=(value)
     @render_as = value.to_sym
   end
 
 
   ########################################################################
   # Documentation stuff, whee!
   attr_accessor :summary, :description
   def summary=(value)
     value = value.to_s
     value =~ /\n/ and
       raise ArgumentError, "Face summary should be a single line; put the long text in 'description' instead."
 
     @summary = value
   end
 
 
   ########################################################################
   # Initially, this was defined to allow the @action.invoke pattern, which is
   # a very natural way to invoke behaviour given our introspection
   # capabilities.   Heck, our initial plan was to have the faces delegate to
   # the action object for invocation and all.
   #
   # It turns out that we have a binding problem to solve: @face was bound to
   # the parent class, not the subclass instance, and we don't pass the
   # appropriate context or change the binding enough to make this work.
   #
   # We could hack around it, by either mandating that you pass the context in
   # to invoke, or try to get the binding right, but that has probably got
   # subtleties that we don't instantly think of – especially around threads.
   #
   # So, we are pulling this method for now, and will return it to life when we
   # have the time to resolve the problem.  For now, you should replace...
   #
   #     @action = @face.get_action(name)
   #     @action.invoke(arg1, arg2, arg3)
   #
   # ...with...
   #
   #     @action = @face.get_action(name)
   #     @face.send(@action.name, arg1, arg2, arg3)
   #
   # I understand that is somewhat cumbersome, but it functions as desired.
   # --daniel 2011-03-31
   #
   # PS: This code is left present, but commented, to support this chunk of
   # documentation, for the benefit of the reader.
   #
   # def invoke(*args, &block)
   #   @face.send(name, *args, &block)
   # end
 
+
+  # We need to build an instance method as a wrapper, using normal code, to be
+  # able to expose argument defaulting between the caller and definer in the
+  # Ruby API.  An extra method is, sadly, required for Ruby 1.8 to work since
+  # it doesn't expose bind on a block.
+  #
+  # Hopefully we can improve this when we finally shuffle off the last of Ruby
+  # 1.8 support, but that looks to be a few "enterprise" release eras away, so
+  # we are pretty stuck with this for now.
+  #
+  # Patches to make this work more nicely with Ruby 1.9 using runtime version
+  # checking and all are welcome, provided that they don't change anything
+  # outside this little ol' bit of code and all.
+  #
+  # Incidentally, we though about vendoring evil-ruby and actually adjusting
+  # the internal C structure implementation details under the hood to make
+  # this stuff work, because it would have been cleaner.  Which gives you an
+  # idea how motivated we were to make this cleaner.  Sorry.
+  # --daniel 2011-03-31
   def when_invoked=(block)
-    # We need to build an instance method as a wrapper, using normal code, to
-    # be able to expose argument defaulting between the caller and definer in
-    # the Ruby API.  An extra method is, sadly, required for Ruby 1.8 to work.
-    #
-    # In future this also gives us a place to hook in additional behaviour
-    # such as calling out to the action instance to validate and coerce
-    # parameters, which avoids any exciting context switching and all.
-    #
-    # Hopefully we can improve this when we finally shuffle off the last of
-    # Ruby 1.8 support, but that looks to be a few "enterprise" release eras
-    # away, so we are pretty stuck with this for now.
-    #
-    # Patches to make this work more nicely with Ruby 1.9 using runtime
-    # version checking and all are welcome, but they can't actually help if
-    # the results are not totally hidden away in here.
-    #
-    # Incidentally, we though about vendoring evil-ruby and actually adjusting
-    # the internal C structure implementation details under the hood to make
-    # this stuff work, because it would have been cleaner.  Which gives you an
-    # idea how motivated we were to make this cleaner.  Sorry. --daniel 2011-03-31
 
     internal_name = "#{@name} implementation, required on Ruby 1.8".to_sym
-    file    = __FILE__ + "+eval"
-    line    = __LINE__ + 1
+
+    arity = block.arity
+    if arity == 0 then
+      # This will never fire on 1.8.7, which treats no arguments as "*args",
+      # but will on 1.9.2, which treats it as "no arguments".  Which bites,
+      # because this just begs for us to wind up in the horrible situation
+      # where a 1.8 vs 1.9 error bites our end users. --daniel 2011-04-19
+      raise ArgumentError, "action when_invoked requires at least one argument (options)"
+    elsif arity > 0 then
+      range = Range.new(1, arity - 1)
+      decl = range.map { |x| "arg#{x}" } << "options = {}"
+      optn = ""
+      args = "[" + (range.map { |x| "arg#{x}" } << "options").join(", ") + "]"
+    else
+      range = Range.new(1, arity.abs - 1)
+      decl = range.map { |x| "arg#{x}" } << "*rest"
+      optn = "rest << {} unless rest.last.is_a?(Hash)"
+      if arity == -1 then
+        args = "rest"
+      else
+        args = "[" + range.map { |x| "arg#{x}" }.join(", ") + "] + rest"
+      end
+    end
+
+    file    = __FILE__ + "+eval[wrapper]"
+    line    = __LINE__ + 2 # <== points to the same line as 'def' in the wrapper.
     wrapper = <<WRAPPER
-def #{@name}(*args)
-  if args.last.is_a? Hash then
-    options = args.last
-  else
-    args << (options = {})
-  end
+def #{@name}(#{decl.join(", ")})
+  #{optn}
+  args = #{args}
+  options = args.last
 
   action = get_action(#{name.inspect})
   action.validate_args(args)
   __invoke_decorations(:before, action, args, options)
   rval = self.__send__(#{internal_name.inspect}, *args)
   __invoke_decorations(:after, action, args, options)
   return rval
 end
 WRAPPER
 
     if @face.is_a?(Class)
       @face.class_eval do eval wrapper, nil, file, line end
       @face.define_method(internal_name, &block)
     else
       @face.instance_eval do eval wrapper, nil, file, line end
       @face.meta_def(internal_name, &block)
     end
   end
 
   def add_option(option)
     option.aliases.each do |name|
       if conflict = get_option(name) then
         raise ArgumentError, "Option #{option} conflicts with existing option #{conflict}"
       elsif conflict = @face.get_option(name) then
         raise ArgumentError, "Option #{option} conflicts with existing option #{conflict} on #{@face}"
       end
     end
 
     option.aliases.each do |name|
       @options[name] = option
     end
 
     option
   end
 
   def option?(name)
     @options.include? name.to_sym
   end
 
   def options
     (@options.keys + @face.options).sort
   end
 
   def get_option(name, with_inherited_options = true)
     option = @options[name.to_sym]
     if option.nil? and with_inherited_options
       option = @face.get_option(name)
     end
     option
   end
 
   def validate_args(args)
     required = options.map do |name|
       get_option(name)
     end.select(&:required?).collect(&:name) - args.last.keys
 
     return if required.empty?
     raise ArgumentError, "missing required options (#{required.join(', ')})"
   end
 
   ########################################################################
   # Support code for action decoration; see puppet/interface.rb for the gory
   # details of why this is hidden away behind private. --daniel 2011-04-15
   private
   def __add_method(name, proc)
     @face.__send__ :__add_method, name, proc
   end
 end
diff --git a/lib/puppet/interface/face_collection.rb b/lib/puppet/interface/face_collection.rb
index 591471d4b..6e6afc545 100644
--- a/lib/puppet/interface/face_collection.rb
+++ b/lib/puppet/interface/face_collection.rb
@@ -1,131 +1,143 @@
 # -*- coding: utf-8 -*-
 require 'puppet/interface'
 
 module Puppet::Interface::FaceCollection
   SEMVER_VERSION = /^(\d+)\.(\d+)\.(\d+)([A-Za-z][0-9A-Za-z-]*|)$/
 
   @faces = Hash.new { |hash, key| hash[key] = {} }
 
   def self.faces
     unless @loaded
       @loaded = true
       $LOAD_PATH.each do |dir|
         next unless FileTest.directory?(dir)
         Dir.chdir(dir) do
           Dir.glob("puppet/face/*.rb").collect { |f| f.sub(/\.rb/, '') }.each do |file|
             iname = file.sub(/\.rb/, '')
             begin
               require iname
             rescue Exception => detail
               puts detail.backtrace if Puppet[:trace]
               raise "Could not load #{iname} from #{dir}/#{file}: #{detail}"
             end
           end
         end
       end
     end
-    return @faces.keys
+    return @faces.keys.select {|name| @faces[name].length > 0 }
   end
 
   def self.validate_version(version)
     !!(SEMVER_VERSION =~ version.to_s)
   end
 
+  def self.semver_to_array(v)
+    parts = SEMVER_VERSION.match(v).to_a[1..4]
+    parts[0..2] = parts[0..2].map { |e| e.to_i }
+    parts
+  end
+
   def self.cmp_semver(a, b)
-    a, b = [a, b].map do |x|
-      parts = SEMVER_VERSION.match(x).to_a[1..4]
-      parts[0..2] = parts[0..2].map { |e| e.to_i }
-      parts
-    end
+    a, b = [a, b].map do |x| semver_to_array(x) end
 
     cmp = a[0..2] <=> b[0..2]
     if cmp == 0
       cmp = a[3] <=> b[3]
       cmp = +1 if a[3].empty? && !b[3].empty?
       cmp = -1 if b[3].empty? && !a[3].empty?
     end
     cmp
   end
 
-  def self.[](name, version)
-    @faces[underscorize(name)][version] if face?(name, version)
+  def self.prefix_match?(desired, target)
+    # Can't meaningfully do a prefix match with current on either side.
+    return false if desired == :current
+    return false if target  == :current
+
+    # REVISIT: Should probably fail if the matcher is not valid.
+    prefix = desired.split('.').map {|x| x =~ /^\d+$/ and x.to_i }
+    have   = semver_to_array(target)
+
+    while want = prefix.shift do
+      return false unless want == have.shift
+    end
+    return true
   end
 
-  def self.face?(name, version)
+  def self.[](name, version)
     name = underscorize(name)
+    get_face(name, version) or load_face(name, version)
+  end
 
-    # Note: be careful not to accidentally create the top level key, either,
-    # because it will result in confusion when people try to enumerate the
-    # list of valid faces later. --daniel 2011-04-11
-    return true if @faces.has_key?(name) and @faces[name].has_key?(version)
+  # get face from memory, without loading.
+  def self.get_face(name, desired_version)
+    return nil unless @faces.has_key? name
 
+    return @faces[name][:current] if desired_version == :current
+
+    found = @faces[name].keys.select {|v| prefix_match?(desired_version, v) }.sort.last
+    return @faces[name][found]
+  end
+
+  # try to load the face, and return it.
+  def self.load_face(name, version)
     # We always load the current version file; the common case is that we have
     # the expected version and any compatibility versions in the same file,
     # the default.  Which means that this is almost always the case.
     #
     # We use require to avoid executing the code multiple times, like any
     # other Ruby library that we might want to use.  --daniel 2011-04-06
     begin
       require "puppet/face/#{name}"
 
       # If we wanted :current, we need to index to find that; direct version
       # requests just work™ as they go. --daniel 2011-04-06
       if version == :current then
         # We need to find current out of this.  This is the largest version
         # number that doesn't have a dedicated on-disk file present; those
         # represent "experimental" versions of faces, which we don't fully
         # support yet.
         #
         # We walk the versions from highest to lowest and take the first version
         # that is not defined in an explicitly versioned file on disk as the
         # current version.
         #
         # This constrains us to only ship experimental versions with *one*
         # version in the file, not multiple, but given you can't reliably load
         # them except by side-effect when you ignore that rule this seems safe
         # enough...
         #
         # Given those constraints, and that we are not going to ship a versioned
         # interface that is not :current in this release, we are going to leave
         # these thoughts in place, and just punt on the actual versioning.
         #
         # When we upgrade the core to support multiple versions we can solve the
         # problems then; as lazy as possible.
         #
         # We do support multiple versions in the same file, though, so we sort
         # versions here and return the last item in that set.
         #
         # --daniel 2011-04-06
         latest_ver = @faces[name].keys.sort {|a, b| cmp_semver(a, b) }.last
         @faces[name][:current] = @faces[name][latest_ver]
       end
     rescue LoadError => e
       raise unless e.message =~ %r{-- puppet/face/#{name}$}
       # ...guess we didn't find the file; return a much better problem.
     end
 
-    # Now, either we have the version in our set of faces, or we didn't find
-    # the version they were looking for.  In the future we will support
-    # loading versioned stuff from some look-aside part of the Ruby load path,
-    # but we don't need that right now.
-    #
-    # So, this comment is a place-holder for that.  --daniel 2011-04-06
-    #
-    # Note: be careful not to accidentally create the top level key, either,
-    # because it will result in confusion when people try to enumerate the
-    # list of valid faces later. --daniel 2011-04-11
-    return !! (@faces.has_key?(name) and @faces[name].has_key?(version))
+    return get_face(name, version)
   end
 
   def self.register(face)
     @faces[underscorize(face.name)][face.version] = face
   end
 
   def self.underscorize(name)
     unless name.to_s =~ /^[-_a-z]+$/i then
       raise ArgumentError, "#{name.inspect} (#{name.class}) is not a valid face name"
     end
 
     name.to_s.downcase.split(/[-_]/).join('_').to_sym
   end
 end
diff --git a/lib/puppet/util/monkey_patches.rb b/lib/puppet/util/monkey_patches.rb
index 10a268409..bd954c665 100644
--- a/lib/puppet/util/monkey_patches.rb
+++ b/lib/puppet/util/monkey_patches.rb
@@ -1,106 +1,113 @@
 
 unless defined? JRUBY_VERSION
   Process.maxgroups = 1024
 end
 
 module RDoc
   def self.caller(skip=nil)
     in_gem_wrapper = false
     Kernel.caller.reject { |call|
       in_gem_wrapper ||= call =~ /#{Regexp.escape $0}:\d+:in `load'/
     }
   end
 end
 
 
 require "yaml"
 require "puppet/util/zaml.rb"
 
 class Symbol
   def to_zaml(z)
     z.emit("!ruby/sym ")
     to_s.to_zaml(z)
   end
   def <=> (other)
     self.to_s <=> other.to_s
   end
 end
 
 [Object, Exception, Integer, Struct, Date, Time, Range, Regexp, Hash, Array, Float, String, FalseClass, TrueClass, Symbol, NilClass, Class].each { |cls|
   cls.class_eval do
     def to_yaml(ignored=nil)
       ZAML.dump(self)
     end
   end
 }
 
 def YAML.dump(*args)
   ZAML.dump(*args)
 end
 
 #
 # Workaround for bug in MRI 1.8.7, see
 #     http://redmine.ruby-lang.org/issues/show/2708
 # for details
 #
 if RUBY_VERSION == '1.8.7'
   class NilClass
     def closed?
       true
     end
   end
 end
 
 class Object
   # ActiveSupport 2.3.x mixes in a dangerous method
   # that can cause rspec to fork bomb
   # and other strange things like that.
   def daemonize
     raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
   end
 
   # The following code allows callers to make assertions that are only
   # checked when the environment variable PUPPET_ENABLE_ASSERTIONS is
   # set to a non-empty string.  For example:
   #
   #   assert_that { condition }
   #   assert_that(message) { condition }
   if ENV["PUPPET_ENABLE_ASSERTIONS"].to_s != ''
     def assert_that(message = nil)
       unless yield
         raise Exception.new("Assertion failure: #{message}")
       end
     end
   else
     def assert_that(message = nil)
     end
   end
 end
 
 # Workaround for yaml_initialize, which isn't supported before Ruby
 # 1.8.3.
 if RUBY_VERSION == '1.8.1' || RUBY_VERSION == '1.8.2'
   YAML.add_ruby_type( /^object/ ) { |tag, val|
     type, obj_class = YAML.read_type_class( tag, Object )
     r = YAML.object_maker( obj_class, val )
     if r.respond_to? :yaml_initialize
       r.instance_eval { instance_variables.each { |name| remove_instance_variable name } }
       r.yaml_initialize(tag, val)
     end
     r
   }
 end
 
 class Array
   # Ruby < 1.8.7 doesn't have this method but we use it in tests
   def combination(num)
     return [] if num < 0 || num > size
     return [[]] if num == 0
     return map{|e| [e] } if num == 1
     tmp = self.dup
     self[0, size - (num - 1)].inject([]) do |ret, e|
       tmp.shift
       ret += tmp.combination(num - 1).map{|a| a.unshift(e) }
     end
   end unless method_defined? :combination
 end
+
+
+class Symbol
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end unless method_defined? :to_proc
+end
diff --git a/spec/lib/puppet/face/version_matching.rb b/spec/lib/puppet/face/version_matching.rb
new file mode 100644
index 000000000..bfd0013f7
--- /dev/null
+++ b/spec/lib/puppet/face/version_matching.rb
@@ -0,0 +1,10 @@
+require 'puppet/face'
+
+# The set of versions here are used explicitly in the interface_spec; if you
+# change this you need to ensure that is still correct. --daniel 2011-04-21
+['1.0.0', '1.0.1', '1.1.0', '1.1.1', '2.0.0'].each do |version|
+  Puppet::Face.define(:version_matching, version) do
+    summary "version matching face #{version}"
+    script :version do version end
+  end
+end
diff --git a/spec/monkey_patches/disable_signal_trap.rb b/spec/monkey_patches/disable_signal_trap.rb
new file mode 100644
index 000000000..5159626e3
--- /dev/null
+++ b/spec/monkey_patches/disable_signal_trap.rb
@@ -0,0 +1,5 @@
+module Signal
+  def trap(*args)
+    # The goggles, they do nothing!
+  end
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 1187c1caf..01ffabc48 100755
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,74 +1,82 @@
 dir = File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH.unshift File.join(dir, 'lib')
 
 # Don't want puppet getting the command line arguments for rake or autotest
 ARGV.clear
 
 require 'puppet'
 require 'mocha'
 gem 'rspec', '>=2.0.0'
 require 'rspec/expectations'
 
 # So everyone else doesn't have to include this base constant.
 module PuppetSpec
   FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
 end
 
 require 'pathname'
 require 'tmpdir'
 
 require 'lib/puppet_spec/verbose'
 require 'lib/puppet_spec/files'
 require 'lib/puppet_spec/fixtures'
 require 'monkey_patches/alias_should_to_must'
 require 'monkey_patches/publicize_methods'
+require 'monkey_patches/disable_signal_trap'
 
 Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
   require behaviour.relative_path_from(Pathname.new(dir))
 end
 
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 
   config.mock_with :mocha
 
   config.before :each do
     GC.disable
 
     # these globals are set by Application
     $puppet_application_mode = nil
     $puppet_application_name = nil
+
+    # REVISIT: I think this conceals other bad tests, but I don't have time to
+    # fully diagnose those right now.  When you read this, please come tell me
+    # I suck for letting this float. --daniel 2011-04-21
     Signal.stubs(:trap)
 
     # Set the confdir and vardir to gibberish so that tests
     # have to be correctly mocked.
     Puppet[:confdir] = "/dev/null"
     Puppet[:vardir] = "/dev/null"
 
     # Avoid opening ports to the outside world
     Puppet.settings[:bindaddress] = "127.0.0.1"
 
     @logs = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
+
+    @log_level = Puppet::Util::Log.level
   end
 
   config.after :each do
     Puppet.settings.clear
     Puppet::Node::Environment.clear
     Puppet::Util::Storage.clear
     Puppet::Util::ExecutionStub.reset
 
     PuppetSpec::Files.cleanup
 
     @logs.clear
     Puppet::Util::Log.close_all
+    Puppet::Util::Log.level = @log_level
 
     GC.enable
   end
 end
 
 RSpec::Matchers.define :have_matching_element do |expected|
   match do |actual|
     actual.any? { |item| item =~ expected }
   end
 end
diff --git a/spec/unit/application/agent_spec.rb b/spec/unit/application/agent_spec.rb
index 03cf14429..b30a8cc6c 100755
--- a/spec/unit/application/agent_spec.rb
+++ b/spec/unit/application/agent_spec.rb
@@ -1,592 +1,587 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/agent'
 require 'puppet/application/agent'
 require 'puppet/network/server'
 require 'puppet/daemon'
 require 'puppet/network/handler'
 
 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)
     Puppet[:daemonize] = false
     @agent = stub_everything 'agent'
     Puppet::Agent.stubs(:new).returns(@agent)
     @puppetd.preinit
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
     Puppet::Node::Facts.indirection.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
     it "should catch INT" do
       Signal.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[: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.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[:onetime] = false
         @puppetd.setup_test
         Puppet[:onetime].should == true
       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
+        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)
-
-        Puppet::Util::Log.expects(:level=).with(:info)
-
         @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)
 
           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[:configprint] = "pluginsync"
 
       Puppet.settings.expects(:print_configs)
 
       @puppetd.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet[:modulepath] = '/my/path'
       Puppet[:configprint] = "modulepath"
       Puppet::Util::Settings.any_instance.expects(:puts).with('/my/path')
       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[:server] = "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.indirection.expects(:terminus_class=).with(:rest)
 
       @puppetd.setup
     end
 
     it "should tell the report handler to cache locally as yaml" do
       Puppet::Transaction::Report.indirection.expects(:cache_class=).with(:yaml)
 
       @puppetd.setup
     end
 
     it "should change the catalog_terminus setting to 'rest'" do
       Puppet[:catalog_terminus] = :foo
       @puppetd.setup
       Puppet[:catalog_terminus].should ==  :rest
     end
 
     it "should tell the catalog handler to use cache" do
       Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:yaml)
 
       @puppetd.setup
     end
 
     it "should change the facts_terminus setting to 'facter'" do
       Puppet[:facts_terminus] = :foo
 
       @puppetd.setup
       Puppet[:facts_terminus].should == :facter
     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[:daemonize] = 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[:listen] = 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[:authconfig] = '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(Puppet[:authconfig]).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[:puppetport] = 32768
 
         Puppet::Network::Server.expects(:new).with { |args| args[:port] == 32768 }
 
         @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[:noop] = false
           report = stub 'report', :exit_status => 666
           @agent.stubs(:run).returns(report)
           @puppetd.expects(:exit).with(666)
 
           @puppetd.onetime
         end
 
         it "should exit with the report's computer exit status, even if --noop is set." do
           Puppet[:noop] = true
           report = stub 'report', :exit_status => 666
           @agent.stubs(:run).returns(report)
           @puppetd.expects(:exit).with(666)
 
           @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/apply_spec.rb b/spec/unit/application/apply_spec.rb
index dca2a4156..ec3f083db 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -1,390 +1,384 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/apply'
 require 'puppet/file_bucket/dipper'
 require 'puppet/configurer'
 
 describe Puppet::Application::Apply do
   before :each do
     @apply = Puppet::Application[:apply]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   [:debug,:loadclasses,:verbose,:use_nodes,:detailed_exitcodes].each do |option|
     it "should declare handle_#{option} method" do
       @apply.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @apply.options.expects(:[]=).with(option, 'arg')
       @apply.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   it "should set the code to the provided code when :execute is used" do
     @apply.options.expects(:[]=).with(:code, 'arg')
     @apply.send("handle_execute".to_sym, 'arg')
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @apply.should_parse_config?.should be_true
   end
 
   describe "when applying options" do
 
     it "should set the log destination with --logdest" do
       Puppet::Log.expects(:newdestination).with("console")
 
       @apply.handle_logdest("console")
     end
 
     it "should put the logset options to true" do
       @apply.options.expects(:[]=).with(:logset,true)
 
       @apply.handle_logdest("console")
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       STDIN.stubs(:read)
       Puppet::Transaction::Report.indirection.stubs(:cache_class=)
 
       @apply.options.stubs(:[]).with(any_parameters)
     end
 
     it "should set show_diff on --noop" do
       Puppet.stubs(:[]=)
       Puppet.stubs(:[]).with(:config)
       Puppet.stubs(:[]).with(:noop).returns(true)
 
       Puppet.expects(:[]=).with(:show_diff, true)
 
       @apply.setup
     end
 
     it "should set console as the log destination if logdest option wasn't provided" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @apply.setup
     end
 
     it "should set INT trap" do
       Signal.expects(:trap).with(:INT)
 
       @apply.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @apply.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @apply.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @apply.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @apply.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @apply.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @apply.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @apply.setup }.should raise_error(SystemExit)
     end
 
     it "should tell the report handler to cache locally as yaml" do
       Puppet::Transaction::Report.indirection.expects(:cache_class=).with(:yaml)
 
       @apply.setup
     end
   end
 
   describe "when executing" do
 
     it "should dispatch to 'apply' if it was called with 'apply'" do
       @apply.options[:catalog] = "foo"
 
       @apply.expects(:apply)
       @apply.run_command
     end
 
     it "should dispatch to main otherwise" do
       @apply.stubs(:options).returns({})
 
       @apply.expects(:main)
       @apply.run_command
     end
 
     describe "the main command" do
       before :each do
         Puppet.stubs(:[])
         Puppet.settings.stubs(:use)
         Puppet.stubs(:[]).with(:prerun_command).returns ""
         Puppet.stubs(:[]).with(:postrun_command).returns ""
         Puppet.stubs(:[]).with(:trace).returns(true)
 
         @apply.options.stubs(:[])
 
         @facts = stub_everything 'facts'
         Puppet::Node::Facts.indirection.stubs(:find).returns(@facts)
 
         @node = stub_everything 'node'
         Puppet::Node.indirection.stubs(:find).returns(@node)
 
         @catalog = stub_everything 'catalog'
         @catalog.stubs(:to_ral).returns(@catalog)
         Puppet::Resource::Catalog.indirection.stubs(:find).returns(@catalog)
 
         STDIN.stubs(:read)
 
         @transaction = stub_everything 'transaction'
         @catalog.stubs(:apply).returns(@transaction)
 
         @apply.stubs(:exit)
 
         Puppet::Util::Storage.stubs(:load)
         Puppet::Configurer.any_instance.stubs(:save_last_run_summary) # to prevent it from trying to write files
       end
 
       it "should set the code to run from --code" do
         @apply.options.stubs(:[]).with(:code).returns("code to run")
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
       end
 
       it "should set the code to run from STDIN if no arguments" do
         @apply.command_line.stubs(:args).returns([])
         STDIN.stubs(:read).returns("code to run")
 
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
       end
 
       it "should set the manifest if a file is passed on command line and the file exists" do
         File.stubs(:exist?).with('site.pp').returns true
         @apply.command_line.stubs(:args).returns(['site.pp'])
 
         Puppet.expects(:[]=).with(:manifest,"site.pp")
 
         @apply.main
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
         File.stubs(:exist?).with('noexist.pp').returns false
         @apply.command_line.stubs(:args).returns(['noexist.pp'])
         lambda { @apply.main }.should raise_error(RuntimeError, 'Could not find file noexist.pp')
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
         File.stubs(:exist?).with('starwarsIV').returns true
         File.expects(:exist?).with('starwarsI').never
         @apply.command_line.stubs(:args).returns(['starwarsIV', 'starwarsI', 'starwarsII'])
 
         Puppet.expects(:[]=).with(:manifest,"starwarsIV")
         Puppet.expects(:warning).with('Only one file can be applied per run.  Skipping starwarsI, starwarsII')
 
         @apply.main
       end
 
       it "should collect the node facts" do
         Puppet::Node::Facts.indirection.expects(:find).returns(@facts)
 
         @apply.main
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node::Facts.indirection.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should look for the node" do
         Puppet::Node.indirection.expects(:find).returns(@node)
 
         @apply.main
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node.indirection.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should merge in our node the loaded facts" do
         @facts.stubs(:values).returns("values")
 
         @node.expects(:merge).with("values")
 
         @apply.main
       end
 
       it "should load custom classes if loadclasses" do
         @apply.options.stubs(:[]).with(:loadclasses).returns(true)
         Puppet.stubs(:[]).with(:classfile).returns("/etc/puppet/classes.txt")
         FileTest.stubs(:exists?).with("/etc/puppet/classes.txt").returns(true)
         FileTest.stubs(:readable?).with("/etc/puppet/classes.txt").returns(true)
         File.stubs(:read).with("/etc/puppet/classes.txt").returns("class")
 
         @node.expects(:classes=)
 
         @apply.main
       end
 
       it "should compile the catalog" do
         Puppet::Resource::Catalog.indirection.expects(:find).returns(@catalog)
 
         @apply.main
       end
 
       it "should transform the catalog to ral" do
 
         @catalog.expects(:to_ral).returns(@catalog)
 
         @apply.main
       end
 
       it "should finalize the catalog" do
         @catalog.expects(:finalize)
 
         @apply.main
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
         Puppet::Configurer.any_instance.expects(:execute_prerun_command)
         Puppet::Configurer.any_instance.expects(:execute_postrun_command)
 
         @apply.main
       end
 
       it "should apply the catalog" do
         @catalog.expects(:apply).returns(stub_everything('transaction'))
 
         @apply.main
       end
 
       it "should save the last run summary" do
         Puppet.stubs(:[]).with(:noop).returns(false)
         report = Puppet::Transaction::Report.new("apply")
         Puppet::Transaction::Report.stubs(:new).returns(report)
 
         Puppet::Configurer.any_instance.expects(:save_last_run_summary).with(report)
         @apply.main
       end
 
       describe "with detailed_exitcodes" do
         it "should exit with report's computed exit status" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
           @apply.expects(:exit).with(666)
 
           @apply.main
         end
 
         it "should exit with report's computed exit status, even if --noop is set" do
           Puppet.stubs(:[]).with(:noop).returns(true)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
           @apply.expects(:exit).with(666)
 
           @apply.main
         end
 
         it "should always exit with 0 if option is disabled" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
 
           @apply.main
         end
 
         it "should always exit with 0 if --noop" do
           Puppet.stubs(:[]).with(:noop).returns(true)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
 
           @apply.main
         end
       end
     end
 
     describe "the 'apply' command" do
       it "should read the catalog in from disk if a file name is provided" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.expects(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should read the catalog in from stdin if '-' is provided" do
         @apply.options[:catalog] = "-"
         $stdin.expects(:read).returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should deserialize the catalog from the default format" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
         Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should fail helpfully if deserializing fails" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something syntacically invalid"
         lambda { @apply.apply }.should raise_error(Puppet::Error)
       end
 
       it "should convert plain data structures into a catalog if deserialization does not do so" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,"something").returns({:foo => "bar"})
         Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
         @apply.apply
       end
 
       it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns catalog
         catalog.expects(:to_ral).returns "mycatalog"
 
         configurer = stub 'configurer'
         Puppet::Configurer.expects(:new).returns configurer
         configurer.expects(:run).with(:catalog => "mycatalog")
 
         @apply.apply
       end
     end
   end
 end
diff --git a/spec/unit/application/cert_spec.rb b/spec/unit/application/cert_spec.rb
index a1b5eb19a..4a91c1e6c 100755
--- a/spec/unit/application/cert_spec.rb
+++ b/spec/unit/application/cert_spec.rb
@@ -1,222 +1,216 @@
 #!/usr/bin/env rspec
 require '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)
+    Puppet::Log.level.should == :info
   end
 
   it "should set log level to debug with the --debug option" do
-
-    Puppet::Log.expects(:level=).with(:debug)
-
     @cert_app.handle_debug(0)
+    Puppet::Log.level.should == :debug
   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.subcommand.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.subcommand.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
 
     it "should set the ca_location to :local if the cert_mode is generate" do
       @cert_app.subcommand = 'generate'
       Puppet::SSL::Host.expects(:ca_location=).with(:local)
       @cert_app.setup
     end
 
     it "should set the ca_location to :local if the cert_mode is destroy" do
       @cert_app.subcommand = 'destroy'
       Puppet::SSL::Host.expects(:ca_location=).with(:local)
       @cert_app.setup
     end
 
     it "should set the ca_location to :only if the cert_mode is print" do
       @cert_app.subcommand = 'print'
       Puppet::SSL::Host.expects(:ca_location=).with(:only)
       @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 revoke cert if cert_mode is clean" do
       @cert_app.subcommand = :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
 
   describe "when identifying subcommands" do
     before :each do
       @cert_app.all = false
       @ca = stub_everything 'ca'
       @cert_app.ca = @ca
     end
 
     %w{list revoke generate sign print verify fingerprint}.each do |cmd|
       short = cmd[0,1]
       [cmd, "--#{cmd}", "-#{short}"].each do |option|
         # In our command line '-v' was eaten by 'verbose', so we can't consume
         # it here; this is a special case from our otherwise standard
         # processing. --daniel 2011-02-22
         next if option == "-v"
 
         it "should recognise '#{option}'" do
           args = [option, "fun.example.com"]
 
           @cert_app.command_line.stubs(:args).returns(args)
           @cert_app.parse_options
           @cert_app.subcommand.should == cmd.to_sym
 
           args.should == ["fun.example.com"]
         end
       end
     end
 
     %w{clean --clean -c}.each do |ugly|
       it "should recognise the '#{ugly}' option as destroy" do
         args = [ugly, "fun.example.com"]
 
         @cert_app.command_line.stubs(:args).returns(args)
         @cert_app.parse_options
         @cert_app.subcommand.should == :destroy
 
         args.should == ["fun.example.com"]
       end
     end
   end
 end
diff --git a/spec/unit/application/device_spec.rb b/spec/unit/application/device_spec.rb
old mode 100644
new mode 100755
index 086e321e9..832b7e55b
--- a/spec/unit/application/device_spec.rb
+++ b/spec/unit/application/device_spec.rb
@@ -1,349 +1,343 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/device'
 require 'puppet/util/network_device/config'
 require 'ostruct'
 require 'puppet/configurer'
 
 describe Puppet::Application::Device do
   before :each do
     @device = Puppet::Application[:device]
-#    @device.stubs(:puts)
     @device.preinit
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
     Puppet::Node::Facts.indirection.stubs(:terminus_class=)
   end
 
   it "should operate in agent run_mode" do
     @device.class.run_mode.name.should == :agent
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @device.should_parse_config?.should be_true
   end
 
   it "should declare a main command" do
     @device.should respond_to(:main)
   end
 
   it "should declare a preinit block" do
     @device.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     before :each do
       @device.stubs(:trap)
     end
 
     it "should catch INT" do
       @device.expects(:trap).with { |arg,block| arg == :INT }
 
       @device.preinit
     end
   end
 
   describe "when handling options" do
     before do
       @device.command_line.stubs(:args).returns([])
     end
 
     [:centrallogging, :debug, :verbose,].each do |option|
       it "should declare handle_#{option} method" do
         @device.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @device.options.expects(:[]=).with(option, 'arg')
         @device.send("handle_#{option}".to_sym, 'arg')
       end
     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)
       @device.setup_host
     end
 
     it "should use supplied waitforcert when --onetime is specified" do
       Puppet[:onetime] = true
       @device.handle_waitforcert(60)
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(60)
       @device.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)
       @device.setup_host
     end
 
     it "should set the log destination with --logdest" do
       @device.options.stubs(:[]=).with { |opt,val| opt == :setdest }
       Puppet::Log.expects(:newdestination).with("console")
 
       @device.handle_logdest("console")
     end
 
     it "should put the setdest options to true" do
       @device.options.expects(:[]=).with(:setdest,true)
 
       @device.handle_logdest("console")
     end
 
     it "should parse the log destination from the command line" do
       @device.command_line.stubs(:args).returns(%w{--logdest /my/file})
 
       Puppet::Util::Log.expects(:newdestination).with("/my/file")
 
       @device.parse_options
     end
 
     it "should store the waitforcert options with --waitforcert" do
       @device.options.expects(:[]=).with(:waitforcert,42)
 
       @device.handle_waitforcert("42")
     end
 
     it "should set args[:Port] with --port" do
       @device.handle_port("42")
       @device.args[:Port].should == "42"
     end
 
   end
 
   describe "during setup" do
     before :each do
       @device.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::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
 
     it "should call setup_logs" do
       @device.expects(:setup_logs)
       @device.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
         @device.options.stubs(:[]).with(:debug).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:debug)
-
         @device.setup_logs
+        Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose was passed" do
         @device.options.stubs(:[]).with(:verbose).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:info)
-
         @device.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
           @device.options.stubs(:[]).with(level).returns(true)
 
           Puppet::Util::Log.expects(:newdestination).with(:console)
 
           @device.setup_logs
         end
       end
 
       it "should set syslog as the log destination if no --logdest" do
         @device.options.stubs(:[]).with(:setdest).returns(false)
 
         Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
         @device.setup_logs
       end
 
     end
 
     it "should set a central log destination with --centrallogs" do
       @device.options.stubs(:[]).with(:centrallogs).returns(true)
       Puppet[:server] = "puppet.reductivelabs.com"
       Puppet::Util::Log.stubs(:newdestination).with(:syslog)
 
       Puppet::Util::Log.expects(:newdestination).with("puppet.reductivelabs.com")
 
       @device.setup
     end
 
     it "should use :main, :agent, :device and :ssl config" do
       Puppet.settings.expects(:use).with(:main, :agent, :device, :ssl)
 
       @device.setup
     end
 
     it "should install a remote ca location" do
       Puppet::SSL::Host.expects(:ca_location=).with(:remote)
 
       @device.setup
     end
 
     it "should tell the report handler to use REST" do
       Puppet::Transaction::Report.indirection.expects(:terminus_class=).with(:rest)
 
       @device.setup
     end
 
     it "should change the catalog_terminus setting to 'rest'" do
       Puppet[:catalog_terminus] = :foo
       @device.setup
       Puppet[:catalog_terminus].should ==  :rest
     end
 
     it "should tell the catalog handler to use cache" do
       Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:yaml)
 
       @device.setup
     end
 
     it "should change the facts_terminus setting to 'network_device'" do
       Puppet[:facts_terminus] = :foo
 
       @device.setup
       Puppet[:facts_terminus].should == :network_device
     end
   end
 
   describe "when initializing each devices SSL" do
     before(:each) do
       @host = stub_everything 'host'
       Puppet::SSL::Host.stubs(:new).returns(@host)
     end
 
     it "should create a new ssl host" do
       Puppet::SSL::Host.expects(:new).returns(@host)
       @device.setup_host
     end
 
     it "should wait for a certificate" do
       @device.options.stubs(:[]).with(:waitforcert).returns(123)
       @host.expects(:wait_for_cert).with(123)
 
       @device.setup_host
     end
   end
 
 
   describe "when running" do
     before :each do
       @device.options.stubs(:[]).with(:fingerprint).returns(false)
       Puppet.stubs(:notice)
       @device.options.stubs(:[]).with(:client)
       Puppet::Util::NetworkDevice::Config.stubs(:devices).returns({})
     end
 
     it "should dispatch to main" do
       @device.stubs(:main)
       @device.run_command
     end
 
     it "should get the device list" do
       device_hash = stub_everything 'device hash'
       Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
       @device.main
     end
 
     it "should exit if the device list is empty" do
       @device.expects(:exit).with(1)
       @device.main
     end
 
     describe "for each device" do
       before(:each) do
         Puppet[:vardir] = "/dummy"
         Puppet[:confdir] = "/dummy"
         Puppet[:certname] = "certname"
         @device_hash = {
           "device1" => OpenStruct.new(:name => "device1", :url => "url", :provider => "cisco"),
           "device2" => OpenStruct.new(:name => "device2", :url => "url", :provider => "cisco"),
         }
         Puppet::Util::NetworkDevice::Config.stubs(:devices).returns(@device_hash)
         Puppet.settings.stubs(:set_value)
         Puppet.settings.stubs(:use)
         @device.stubs(:setup_host)
         Puppet::Util::NetworkDevice.stubs(:init)
         @configurer = stub_everything 'configurer'
         Puppet::Configurer.stubs(:new).returns(@configurer)
       end
 
       it "should set vardir to the device vardir" do
         Puppet.settings.expects(:set_value).with(:vardir, "/dummy/devices/device1", :cli)
         @device.main
       end
 
       it "should set confdir to the device confdir" do
         Puppet.settings.expects(:set_value).with(:confdir, "/dummy/devices/device1", :cli)
         @device.main
       end
 
       it "should set certname to the device certname" do
         Puppet.settings.expects(:set_value).with(:certname, "device1", :cli)
         Puppet.settings.expects(:set_value).with(:certname, "device2", :cli)
         @device.main
       end
 
       it "should make sure all the required folders and files are created" do
         Puppet.settings.expects(:use).with(:main, :agent, :ssl).twice
         @device.main
       end
 
       it "should initialize the device singleton" do
         Puppet::Util::NetworkDevice.expects(:init).with(@device_hash["device1"]).then.with(@device_hash["device2"])
         @device.main
       end
 
       it "should setup the SSL context" do
         @device.expects(:setup_host).twice
         @device.main
       end
 
       it "should launch a configurer for this device" do
         @configurer.expects(:run).twice
         @device.main
       end
 
       [:vardir, :confdir].each do |setting|
         it "should cleanup the #{setting} setting after the run" do
           configurer = states('configurer').starts_as('notrun')
           Puppet.settings.expects(:set_value).with(setting, "/dummy/devices/device1", :cli).when(configurer.is('notrun'))
           @configurer.expects(:run).twice.then(configurer.is('run'))
           Puppet.settings.expects(:set_value).with(setting, "/dummy", :cli).when(configurer.is('run'))
 
           @device.main
         end
       end
 
       it "should cleanup the certname setting after the run" do
         configurer = states('configurer').starts_as('notrun')
         Puppet.settings.expects(:set_value).with(:certname, "device1", :cli).when(configurer.is('notrun'))
         @configurer.expects(:run).twice.then(configurer.is('run'))
         Puppet.settings.expects(:set_value).with(:certname, "certname", :cli).when(configurer.is('run'))
 
         @device.main
       end
 
     end
   end
 end
diff --git a/spec/unit/application/doc_spec.rb b/spec/unit/application/doc_spec.rb
index 66a833b9d..43a4b9849 100755
--- a/spec/unit/application/doc_spec.rb
+++ b/spec/unit/application/doc_spec.rb
@@ -1,348 +1,344 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/doc'
 require 'puppet/util/reference'
 require 'puppet/util/rdoc'
 
 describe Puppet::Application::Doc do
   before :each do
     @doc = Puppet::Application[:doc]
     @doc.stubs(:puts)
     @doc.preinit
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
     @doc.should_parse_config?.should be_false
   end
 
   it "should declare a other command" do
     @doc.should respond_to(:other)
   end
 
   it "should declare a rdoc command" do
     @doc.should respond_to(:rdoc)
   end
 
   it "should declare a fallback for unknown options" do
     @doc.should respond_to(:handle_unknown)
   end
 
   it "should declare a preinit block" do
     @doc.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     it "should set references to []" do
       @doc.preinit
 
       @doc.options[:references].should == []
     end
 
     it "should init mode to text" do
       @doc.preinit
 
       @doc.options[:mode].should == :text
     end
 
     it "should init format to to_markdown" do
       @doc.preinit
 
       @doc.options[:format].should == :to_markdown
     end
   end
 
   describe "when handling options" do
     [:all, :outputdir, :verbose, :debug, :charset].each do |option|
       it "should declare handle_#{option} method" do
         @doc.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @doc.options.expects(:[]=).with(option, 'arg')
         @doc.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should store the format if valid" do
       Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(true)
 
       @doc.options.expects(:[]=).with(:format, 'to_format')
 
       @doc.handle_format('format')
     end
 
     it "should raise an error if the format is not valid" do
       Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(false)
       lambda { @doc.handle_format('format') }
     end
 
     it "should store the mode if valid" do
       Puppet::Util::Reference.stubs(:modes).returns(stub('mode', :include? => true))
 
       @doc.options.expects(:[]=).with(:mode, :mode)
 
       @doc.handle_mode('mode')
     end
 
     it "should store the mode if :rdoc" do
       Puppet::Util::Reference.modes.stubs(:include?).with('rdoc').returns(false)
 
       @doc.options.expects(:[]=).with(:mode, :rdoc)
 
       @doc.handle_mode('rdoc')
     end
 
     it "should raise an error if the mode is not valid" do
       Puppet::Util::Reference.modes.stubs(:include?).with('unknown').returns(false)
       lambda { @doc.handle_mode('unknown') }
     end
 
     it "should list all references on list and exit" do
       reference = stubs 'reference'
       ref = stubs 'ref'
       Puppet::Util::Reference.stubs(:references).returns([reference])
 
       Puppet::Util::Reference.expects(:reference).with(reference).returns(ref)
       ref.expects(:doc)
       @doc.expects(:exit)
 
       @doc.handle_list(nil)
     end
 
     it "should add reference to references list with --reference" do
       @doc.options[:references] = [:ref1]
 
       @doc.handle_reference('ref2')
 
       @doc.options[:references].should == [:ref1,:ref2]
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       @doc.command_line.stubs(:args).returns([])
     end
 
     it "should default to rdoc mode if there are command line arguments" do
       @doc.command_line.stubs(:args).returns(["1"])
       @doc.stubs(:setup_rdoc)
 
       @doc.options.expects(:[]=).with(:mode,:rdoc)
 
       @doc.setup
     end
 
     it "should call setup_rdoc in rdoc mode" do
       @doc.options.stubs(:[]).with(:mode).returns(:rdoc)
 
       @doc.expects(:setup_rdoc)
 
       @doc.setup
     end
 
     it "should call setup_reference if not rdoc" do
       @doc.options.stubs(:[]).with(:mode).returns(:test)
 
       @doc.expects(:setup_reference)
 
       @doc.setup
     end
 
     describe "in non-rdoc mode" do
 
       it "should get all non-dynamic reference if --all" do
         @doc.options.stubs(:[]).with(:all).returns(true)
         @doc.options.stubs(:[]).with(:references).returns([])
         static = stub 'static', :dynamic? => false
         dynamic = stub 'dynamic', :dynamic? => true
         Puppet::Util::Reference.stubs(:reference).with(:static).returns(static)
         Puppet::Util::Reference.stubs(:reference).with(:dynamic).returns(dynamic)
         Puppet::Util::Reference.stubs(:references).returns([:static,:dynamic])
 
         @doc.options.stubs(:[]=).with(:references, [:static])
 
         @doc.setup_reference
       end
 
       it "should default to :type if no references" do
         @doc.options.stubs(:[]).with(:all).returns(false)
         array = stub 'array', :empty? => true
         @doc.options.stubs(:[]).with(:references).returns(array)
 
         array.expects(:<<).with(:type)
 
         @doc.setup_reference
       end
 
     end
 
     describe "in rdoc mode" do
 
       before :each do
         @doc.options.stubs(:[]).returns(false)
         Puppet.stubs(:parse_config)
-        Puppet::Util::Log.stubs(:level=)
         Puppet::Util::Log.stubs(:newdestination)
       end
 
       describe "when there are unknown args" do
 
         it "should expand --modulepath if any" do
           @doc.unknown_args = [ { :opt => "--modulepath", :arg => "path" } ]
           Puppet.settings.stubs(:handlearg)
 
           File.expects(:expand_path).with("path")
 
           @doc.setup_rdoc
         end
 
         it "should expand --manifestdir if any" do
           @doc.unknown_args = [ { :opt => "--manifestdir", :arg => "path" } ]
           Puppet.settings.stubs(:handlearg)
 
           File.expects(:expand_path).with("path")
 
           @doc.setup_rdoc
         end
 
         it "should give them to Puppet.settings" do
           @doc.unknown_args = [ { :opt => :option, :arg => :argument } ]
           Puppet.settings.expects(:handlearg).with(:option,:argument)
 
           @doc.setup_rdoc
         end
       end
 
       it "should operate in master run_mode" do
         @doc.class.run_mode.name.should == :master
 
         @doc.setup_rdoc
       end
 
       it "should parse puppet configuration" do
         Puppet.expects(:parse_config)
 
         @doc.setup_rdoc
       end
 
       it "should set log level to debug if --debug" do
         @doc.options.stubs(:[]).with(:debug).returns(true)
-        Puppet::Util::Log.expects(:level=).with(:debug)
-
         @doc.setup_rdoc
+        Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose" do
         @doc.options.stubs(:[]).with(:verbose).returns(true)
-        Puppet::Util::Log.expects(:level=).with(:info)
-
         @doc.setup_rdoc
+        Puppet::Util::Log.level.should == :info
       end
 
       it "should set log destination to console if --verbose" do
         @doc.options.stubs(:[]).with(:verbose).returns(true)
 
         Puppet::Util::Log.expects(:newdestination).with(:console)
 
         @doc.setup_rdoc
       end
 
       it "should set log destination to console if --debug" do
         @doc.options.stubs(:[]).with(:debug).returns(true)
 
         Puppet::Util::Log.expects(:newdestination).with(:console)
 
         @doc.setup_rdoc
       end
 
     end
 
   end
 
   describe "when running" do
 
     describe "in rdoc mode" do
       before :each do
         @doc.manifest = false
         Puppet.stubs(:info)
         Puppet.stubs(:[]).with(:trace).returns(false)
         @env = stub 'env'
         Puppet::Node::Environment.stubs(:new).returns(@env)
         @env.stubs(:modulepath).returns(['modules'])
         @env.stubs(:[]).with(:manifest).returns('manifests/site.pp')
         Puppet.stubs(:[]).with(:modulepath).returns('modules')
         Puppet.stubs(:[]).with(:manifestdir).returns('manifests')
         @doc.options.stubs(:[]).with(:all).returns(false)
         @doc.options.stubs(:[]).with(:outputdir).returns('doc')
         @doc.options.stubs(:[]).with(:charset).returns(nil)
         Puppet.settings.stubs(:[]=).with(:document_all, false)
         Puppet.settings.stubs(:setdefaults)
         Puppet::Util::RDoc.stubs(:rdoc)
         @doc.stubs(:exit)
         File.stubs(:expand_path).with('modules').returns('modules')
         File.stubs(:expand_path).with('manifests').returns('manifests')
         @doc.command_line.stubs(:args).returns([])
       end
 
       it "should set document_all on --all" do
         @doc.options.expects(:[]).with(:all).returns(true)
         Puppet.settings.expects(:[]=).with(:document_all, true)
 
         @doc.rdoc
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode" do
         Puppet::Util::RDoc.expects(:rdoc).with('doc', ['modules','manifests'], nil)
         @doc.rdoc
       end
 
       it "should call Puppet::Util::RDoc.rdoc with a charset if --charset has been provided" do
         @doc.options.expects(:[]).with(:charset).returns("utf-8")
         Puppet::Util::RDoc.expects(:rdoc).with('doc', ['modules','manifests'], "utf-8")
         @doc.rdoc
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode with outputdir set to doc if no --outputdir" do
         @doc.options.expects(:[]).with(:outputdir).returns(false)
         Puppet::Util::RDoc.expects(:rdoc).with('doc', ['modules','manifests'], nil)
         @doc.rdoc
       end
 
       it "should call Puppet::Util::RDoc.manifestdoc in manifest mode" do
         @doc.manifest = true
         Puppet::Util::RDoc.expects(:manifestdoc)
         @doc.rdoc
       end
 
       it "should get modulepath and manifestdir values from the environment" do
         @env.expects(:modulepath).returns(['envmodules1','envmodules2'])
         @env.expects(:[]).with(:manifest).returns('envmanifests/site.pp')
 
         Puppet::Util::RDoc.expects(:rdoc).with('doc', ['envmodules1','envmodules2','envmanifests'], nil)
 
         @doc.rdoc
       end
     end
 
     describe "in the other modes" do
       it "should get reference in given format" do
         reference = stub 'reference'
         @doc.options.stubs(:[]).with(:mode).returns(:none)
         @doc.options.stubs(:[]).with(:references).returns([:ref])
         require 'puppet/util/reference'
         Puppet::Util::Reference.expects(:reference).with(:ref).returns(reference)
         @doc.options.stubs(:[]).with(:format).returns(:format)
         @doc.stubs(:exit)
 
         reference.expects(:send).with { |format,contents| format == :format }.returns('doc')
         @doc.other
       end
     end
 
   end
 end
diff --git a/spec/unit/application/face_base_spec.rb b/spec/unit/application/face_base_spec.rb
index 5403608cf..f7c55c556 100755
--- a/spec/unit/application/face_base_spec.rb
+++ b/spec/unit/application/face_base_spec.rb
@@ -1,274 +1,279 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/application/face_base'
 require 'tmpdir'
 
 class Puppet::Application::FaceBase::Basetest < Puppet::Application::FaceBase
 end
 
 describe Puppet::Application::FaceBase do
   before :all do
     Puppet::Face.define(:basetest, '0.0.1') do
       option("--[no-]boolean")
       option("--mandatory MANDATORY")
 
       action :foo do
         option("--action")
         when_invoked { |*args| args.length }
       end
     end
   end
 
   let :app do
     app = Puppet::Application::FaceBase::Basetest.new
     app.command_line.stubs(:subcommand_name).returns('subcommand')
     Puppet::Util::Log.stubs(:newdestination)
     app
   end
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
       app.find_global_settings_argument("--ca-location").should be_nil
     end
   end
 
   describe "#parse_options" do
     before :each do
       app.command_line.stubs(:args).returns %w{}
     end
 
-    describe "parsing the command line" do
-      context "with just an action" do
-        before :all do
-          # We have to stub Signal.trap to avoid a crazy mess where we take
-          # over signal handling and make it impossible to cancel the test
-          # suite run.
-          #
-          # It would be nice to fix this elsewhere, but it is actually hard to
-          # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
-          Signal.stubs(:trap)
-          app.command_line.stubs(:args).returns %w{foo}
-          app.preinit
-          app.parse_options
-        end
-
-        it "should set the face based on the type" do
-          app.face.name.should == :basetest
-        end
-
-        it "should find the action" do
-          app.action.should be
-          app.action.name.should == :foo
-        end
+    describe "with just an action" do
+      before :all do
+        # We have to stub Signal.trap to avoid a crazy mess where we take
+        # over signal handling and make it impossible to cancel the test
+        # suite run.
+        #
+        # It would be nice to fix this elsewhere, but it is actually hard to
+        # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
+        Signal.stubs(:trap)
+        app.command_line.stubs(:args).returns %w{foo}
+        app.preinit
+        app.parse_options
       end
 
-      it "should use the default action if not given any arguments" do
-        app.command_line.stubs(:args).returns []
-        action = stub(:options => [])
-        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
-        app.stubs(:main)
-        app.run
-        app.action.should == action
-        app.arguments.should == [ { } ]
+      it "should set the face based on the type" do
+        app.face.name.should == :basetest
       end
 
-      it "should use the default action if not given a valid one" do
-        app.command_line.stubs(:args).returns %w{bar}
-        action = stub(:options => [])
-        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
-        app.stubs(:main)
-        app.run
-        app.action.should == action
-        app.arguments.should == [ 'bar', { } ]
+      it "should find the action" do
+        app.action.should be
+        app.action.name.should == :foo
       end
+    end
 
-      it "should have no action if not given a valid one and there is no default action" do
-        app.command_line.stubs(:args).returns %w{bar}
-        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
-        app.stubs(:main)
-        app.run
-        app.action.should be_nil
-        app.arguments.should == [ 'bar', { } ]
-      end
+    it "should use the default action if not given any arguments" do
+      app.command_line.stubs(:args).returns []
+      action = stub(:options => [])
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
+      app.stubs(:main)
+      app.run
+      app.action.should == action
+      app.arguments.should == [ { } ]
+    end
 
-      it "should report a sensible error when options with = fail" do
-        app.command_line.stubs(:args).returns %w{--action=bar foo}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --action/
-      end
+    it "should use the default action if not given a valid one" do
+      app.command_line.stubs(:args).returns %w{bar}
+      action = stub(:options => [])
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
+      app.stubs(:main)
+      app.run
+      app.action.should == action
+      app.arguments.should == [ 'bar', { } ]
+    end
 
-      it "should fail if an action option is before the action" do
-        app.command_line.stubs(:args).returns %w{--action foo}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --action/
-      end
+    it "should have no action if not given a valid one and there is no default action" do
+      app.command_line.stubs(:args).returns %w{bar}
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+      app.stubs(:main)
+      app.run
+      app.action.should be_nil
+      app.arguments.should == [ 'bar', { } ]
+    end
 
-      it "should fail if an unknown option is before the action" do
-        app.command_line.stubs(:args).returns %w{--bar foo}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --bar/
-      end
+    it "should report a sensible error when options with = fail" do
+      app.command_line.stubs(:args).returns %w{--action=bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --action/
+    end
 
-      it "should fail if an unknown option is after the action" do
-        app.command_line.stubs(:args).returns %w{foo --bar}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --bar/
-      end
+    it "should fail if an action option is before the action" do
+      app.command_line.stubs(:args).returns %w{--action foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --action/
+    end
+
+    it "should fail if an unknown option is before the action" do
+      app.command_line.stubs(:args).returns %w{--bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+    end
+
+    it "should fail if an unknown option is after the action" do
+      app.command_line.stubs(:args).returns %w{foo --bar}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+    end
+
+    it "should accept --bar as an argument to a mandatory option after action" do
+      app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
+      app.preinit
+      app.parse_options
+      app.action.name.should == :foo
+      app.options.should == { :mandatory => "--bar" }
+    end
+
+    it "should accept --bar as an argument to a mandatory option before action" do
+      app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
+      app.preinit
+      app.parse_options
+      app.action.name.should == :foo
+      app.options.should == { :mandatory => "--bar" }
+    end
 
-      it "should accept --bar as an argument to a mandatory option after action" do
-        app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
+    it "should not skip when --foo=bar is given" do
+      app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+    end
+
+    { "boolean options before" => %w{--trace foo},
+      "boolean options after"  => %w{foo --trace}
+    }.each do |name, args|
+      it "should accept global boolean settings #{name} the action" do
+        app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
-        app.action.name.should == :foo
-        app.options.should == { :mandatory => "--bar" }
+        Puppet[:trace].should be_true
       end
+    end
 
-      it "should accept --bar as an argument to a mandatory option before action" do
-        app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
+    { "before" => %w{--syslogfacility user1 foo},
+      " after" => %w{foo --syslogfacility user1}
+    }.each do |name, args|
+      it "should accept global settings with arguments #{name} the action" do
+        app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
-        app.action.name.should == :foo
-        app.options.should == { :mandatory => "--bar" }
-      end
-
-      it "should not skip when --foo=bar is given" do
-        app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --bar/
-      end
-
-      { "boolean options before" => %w{--trace foo},
-        "boolean options after"  => %w{foo --trace}
-      }.each do |name, args|
-        it "should accept global boolean settings #{name} the action" do
-          app.command_line.stubs(:args).returns args
-          app.preinit
-          app.parse_options
-          Puppet[:trace].should be_true
-        end
+        Puppet[:syslogfacility].should == "user1"
       end
+    end
 
-      { "before" => %w{--syslogfacility user1 foo},
-        " after" => %w{foo --syslogfacility user1}
-      }.each do |name, args|
-        it "should accept global settings with arguments #{name} the action" do
-          app.command_line.stubs(:args).returns args
-          app.preinit
-          app.parse_options
-          Puppet[:syslogfacility].should == "user1"
-        end
-      end
+    it "should handle application-level options" do
+      app.command_line.stubs(:args).returns %w{help --verbose help}
+      app.preinit
+      app.parse_options
+      app.face.name.should == :basetest
     end
   end
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == [{ :mandatory => "--bar" }]
     end
 
     it "should pass positional arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo bar baz quux}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
     end
   end
 
   describe "#main" do
     before :each do
       app.expects(:exit).with(0)
 
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
       app.arguments = ["myname", "myarg"]
     end
 
     it "should send the specified verb and name to the face" do
       app.face.expects(:foo).with(*app.arguments)
       app.main
     end
 
     it "should lookup help when it cannot do anything else" do
       app.action = nil
       Puppet::Face[:help, :current].expects(:help).with(:basetest, *app.arguments)
       app.stubs(:puts)          # meh.  Don't print nil, thanks. --daniel 2011-04-12
       app.main
     end
 
     it "should use its render method to render any result" do
       app.expects(:render).with(app.arguments.length + 1)
       app.stubs(:puts)          # meh.  Don't print nil, thanks. --daniel 2011-04-12
       app.main
     end
   end
 
   describe "#render" do
     before :each do
       app.face   = Puppet::Face[:basetest, '0.0.1']
       app.action = app.face.get_action(:foo)
     end
 
     ["hello", 1, 1.0].each do |input|
       it "should just return a #{input.class.name}" do
         app.render(input).should == input
       end
     end
 
     [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
       it "should render #{input.class} using the 'pp' library" do
         app.render(input).should == input.pretty_inspect
       end
     end
 
     it "should render a non-trivially-keyed Hash with the 'pp' library" do
       hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
       app.render(hash).should == hash.pretty_inspect
     end
 
     it "should render a {String,Numeric}-keyed Hash into a table" do
       object = Object.new
       hash = { "one" => 1, "two" => [], "three" => {}, "four" => object,
         5 => 5, 6.0 => 6 }
 
       # Gotta love ASCII-betical sort order.  Hope your objects are better
       # structured for display than my test one is. --daniel 2011-04-18
       app.render(hash).should == <<EOT
 5      5
 6.0    6
 four   #{object.pretty_inspect.chomp}
 one    1
 three  {}
 two    []
 EOT
     end
 
     it "should render a hash nicely with a multi-line value" do
       hash = {
         "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
         "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
       }
       app.render(hash).should == <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}
 text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
          "b"=>"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
          "c"=>"cccccccccccccccccccccccccccccccccccccccc"}
 EOT
     end
 
     it "should invoke the action rendering hook while rendering" do
       app.action.set_rendering_method_for(:for_humans, proc { |value| "bi-winning!" })
       app.action.render_as = :for_humans
       app.render("bi-polar?").should == "bi-winning!"
     end
   end
 end
diff --git a/spec/unit/application/filebucket_spec.rb b/spec/unit/application/filebucket_spec.rb
index 8ba86be9e..92bc0410a 100755
--- a/spec/unit/application/filebucket_spec.rb
+++ b/spec/unit/application/filebucket_spec.rb
@@ -1,223 +1,217 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/filebucket'
 require 'puppet/file_bucket/dipper'
 
 describe Puppet::Application::Filebucket do
   before :each do
     @filebucket = Puppet::Application[:filebucket]
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
     @filebucket.should_parse_config?.should be_false
   end
 
   it "should declare a get command" do
     @filebucket.should respond_to(:get)
   end
 
   it "should declare a backup command" do
     @filebucket.should respond_to(:backup)
   end
 
   it "should declare a restore command" do
     @filebucket.should respond_to(:restore)
   end
 
   [:bucket, :debug, :local, :remote, :verbose].each do |option|
     it "should declare handle_#{option} method" do
       @filebucket.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @filebucket.options.expects(:[]=).with("#{option}".to_sym, 'arg')
       @filebucket.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       @filebucket.options.stubs(:[]).with(any_parameters)
     end
 
 
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @filebucket.setup
     end
 
     it "should trap INT" do
       Signal.expects(:trap).with(:INT)
 
       @filebucket.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @filebucket.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @filebucket.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @filebucket.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @filebucket.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
       @filebucket.setup
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @filebucket.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @filebucket.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @filebucket.setup }.should raise_error(SystemExit)
     end
 
     describe "with local bucket" do
 
       before :each do
         @filebucket.options.stubs(:[]).with(:local).returns(true)
       end
 
       it "should create a client with the default bucket if none passed" do
         Puppet.stubs(:[]).with(:bucketdir).returns("path")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Path] == "path" }
 
         @filebucket.setup
       end
 
       it "should create a local Dipper with the given bucket" do
         @filebucket.options.stubs(:[]).with(:bucket).returns("path")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Path] == "path" }
 
         @filebucket.setup
       end
 
     end
 
     describe "with remote bucket" do
 
       it "should create a remote Client to the configured server" do
         Puppet.stubs(:[]).with(:server).returns("puppet.reductivelabs.com")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Server] == "puppet.reductivelabs.com" }
 
         @filebucket.setup
       end
 
     end
 
   end
 
   describe "when running" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       @filebucket.options.stubs(:[]).with(any_parameters)
 
       @client = stub 'client'
       Puppet::FileBucket::Dipper.stubs(:new).returns(@client)
 
       @filebucket.setup
     end
 
     it "should use the first non-option parameter as the dispatch" do
       @filebucket.command_line.stubs(:args).returns(['get'])
 
       @filebucket.expects(:get)
 
       @filebucket.run_command
     end
 
     describe "the command get" do
 
       before :each do
         @filebucket.stubs(:print)
         @filebucket.stubs(:args).returns([])
       end
 
       it "should call the client getfile method" do
         @client.expects(:getfile)
 
         @filebucket.get
       end
 
       it "should call the client getfile method with the given md5" do
         md5="DEADBEEF"
         @filebucket.stubs(:args).returns([md5])
 
         @client.expects(:getfile).with(md5)
 
         @filebucket.get
       end
 
       it "should print the file content" do
         @client.stubs(:getfile).returns("content")
 
         @filebucket.expects(:print).returns("content")
 
         @filebucket.get
       end
 
     end
 
     describe "the command backup" do
       it "should call the client backup method for each given parameter" do
         @filebucket.stubs(:puts)
         FileTest.stubs(:exists?).returns(true)
         FileTest.stubs(:readable?).returns(true)
         @filebucket.stubs(:args).returns(["file1", "file2"])
 
         @client.expects(:backup).with("file1")
         @client.expects(:backup).with("file2")
 
         @filebucket.backup
       end
     end
 
     describe "the command restore" do
       it "should call the client getfile method with the given md5" do
         md5="DEADBEEF"
         file="testfile"
         @filebucket.stubs(:args).returns([file, md5])
 
         @client.expects(:restore).with(file,md5)
 
         @filebucket.restore
       end
     end
 
   end
 
 
 end
diff --git a/spec/unit/application/kick_spec.rb b/spec/unit/application/kick_spec.rb
index 29e4caea4..742c0fff6 100755
--- a/spec/unit/application/kick_spec.rb
+++ b/spec/unit/application/kick_spec.rb
@@ -1,310 +1,304 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/kick'
 
 describe Puppet::Application::Kick, :if => Puppet.features.posix? do
 
   before :each do
     require 'puppet/util/ldap/connection'
     Puppet::Util::Ldap::Connection.stubs(:new).returns(stub_everything)
     @kick = Puppet::Application[:kick]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   describe ".new" do
     it "should take a command-line object as an argument" do
       command_line = stub_everything "command_line"
       lambda{ Puppet::Application::Kick.new( command_line ) }.should_not raise_error
     end
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
     @kick.should_parse_config?.should be_false
   end
 
   it "should declare a main command" do
     @kick.should respond_to(:main)
   end
 
   it "should declare a test command" do
     @kick.should respond_to(:test)
   end
 
   it "should declare a preinit block" do
     @kick.should respond_to(:preinit)
   end
 
   describe "during preinit" do
     before :each do
       @kick.stubs(:trap)
     end
 
     it "should catch INT and TERM" do
       @kick.stubs(:trap).with { |arg,block| arg == :INT or arg == :TERM }
 
       @kick.preinit
     end
 
     it "should set parallel option to 1" do
       @kick.preinit
 
       @kick.options[:parallel].should == 1
     end
 
     it "should set verbose by default" do
       @kick.preinit
 
       @kick.options[:verbose].should be_true
     end
 
     it "should set fqdn by default" do
       @kick.preinit
 
       @kick.options[:fqdn].should be_true
     end
 
     it "should set ignoreschedules to 'false'" do
       @kick.preinit
 
       @kick.options[:ignoreschedules].should be_false
     end
 
     it "should set foreground to 'false'" do
       @kick.preinit
 
       @kick.options[:foreground].should be_false
     end
   end
 
   describe "when applying options" do
 
     before do
       @kick.preinit
     end
 
     [:all, :foreground, :debug, :ping, :test].each do |option|
       it "should declare handle_#{option} method" do
         @kick.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @kick.options.expects(:[]=).with(option, 'arg')
         @kick.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should add to the host list with the host option" do
       @kick.handle_host('host')
 
       @kick.hosts.should == ['host']
     end
 
     it "should add to the tag list with the tag option" do
       @kick.handle_tag('tag')
 
       @kick.tags.should == ['tag']
     end
 
     it "should add to the class list with the class option" do
       @kick.handle_class('class')
 
       @kick.classes.should == ['class']
     end
   end
 
   describe "during setup" do
 
     before :each do
       @kick.classes = []
       @kick.tags = []
       @kick.hosts = []
-      Puppet::Log.stubs(:level=)
       @kick.stubs(:trap)
       @kick.stubs(:puts)
       Puppet.stubs(:parse_config)
 
       @kick.options.stubs(:[]).with(any_parameters)
     end
 
     it "should set log level to debug if --debug was passed" do
       @kick.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @kick.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @kick.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @kick.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
       @kick.setup
     end
 
     describe "when using the ldap node terminus" do
       before :each do
         Puppet.stubs(:[]).with(:node_terminus).returns("ldap")
       end
 
       it "should pass the fqdn option to search" do
         @kick.options.stubs(:[]).with(:fqdn).returns(:something)
         @kick.options.stubs(:[]).with(:all).returns(true)
         @kick.stubs(:puts)
 
         Puppet::Node.indirection.expects(:search).with("whatever",:fqdn => :something).returns([])
 
         @kick.setup
       end
 
       it "should search for all nodes if --all" do
         @kick.options.stubs(:[]).with(:all).returns(true)
         @kick.stubs(:puts)
 
         Puppet::Node.indirection.expects(:search).with("whatever",:fqdn => nil).returns([])
 
         @kick.setup
       end
 
       it "should search for nodes including given classes" do
         @kick.options.stubs(:[]).with(:all).returns(false)
         @kick.stubs(:puts)
         @kick.classes = ['class']
 
         Puppet::Node.indirection.expects(:search).with("whatever", :class => "class", :fqdn => nil).returns([])
 
         @kick.setup
       end
     end
 
     describe "when using regular nodes" do
       it "should fail if some classes have been specified" do
         $stderr.stubs(:puts)
         @kick.classes = ['class']
 
         @kick.expects(:exit).with(24)
 
         @kick.setup
       end
     end
   end
 
   describe "when running" do
     before :each do
       @kick.stubs(:puts)
     end
 
     it "should dispatch to test if --test is used" do
       @kick.options.stubs(:[]).with(:test).returns(true)
 
       @kick.expects(:test)
       @kick.run_command
     end
 
     it "should dispatch to main if --test is not used" do
       @kick.options.stubs(:[]).with(:test).returns(false)
 
       @kick.expects(:main)
       @kick.run_command
     end
 
     describe "the test command" do
       it "should exit with exit code 0 " do
         @kick.expects(:exit).with(0)
 
         @kick.test
       end
     end
 
     describe "the main command" do
       before :each do
         @kick.options.stubs(:[]).with(:parallel).returns(1)
         @kick.options.stubs(:[]).with(:ping).returns(false)
         @kick.options.stubs(:[]).with(:ignoreschedules).returns(false)
         @kick.options.stubs(:[]).with(:foreground).returns(false)
         @kick.options.stubs(:[]).with(:debug).returns(false)
         @kick.stubs(:print)
         @kick.stubs(:exit)
         @kick.preinit
         @kick.stubs(:parse_options)
         @kick.setup
         $stderr.stubs(:puts)
       end
 
       it "should create as much childs as --parallel" do
         @kick.options.stubs(:[]).with(:parallel).returns(3)
         @kick.hosts = ['host1', 'host2', 'host3']
         @kick.stubs(:exit).raises(SystemExit)
         Process.stubs(:wait).returns(1).then.returns(2).then.returns(3).then.raises(Errno::ECHILD)
 
         @kick.expects(:fork).times(3).returns(1).then.returns(2).then.returns(3)
 
         lambda { @kick.main }.should raise_error
       end
 
       it "should delegate to run_for_host per host" do
         @kick.hosts = ['host1', 'host2']
         @kick.stubs(:exit).raises(SystemExit)
         @kick.stubs(:fork).returns(1).yields
         Process.stubs(:wait).returns(1).then.raises(Errno::ECHILD)
 
         @kick.expects(:run_for_host).times(2)
 
         lambda { @kick.main }.should raise_error
       end
 
       describe "during call of run_for_host" do
         before do
           require 'puppet/run'
           options = {
             :background => true, :ignoreschedules => false, :tags => []
           }
           @kick.preinit
           @agent_run = Puppet::Run.new( options.dup )
           @agent_run.stubs(:status).returns("success")
 
           Puppet::Run.indirection.expects(:terminus_class=).with( :rest )
           Puppet::Run.expects(:new).with( options ).returns(@agent_run)
         end
 
         it "should call run on a Puppet::Run for the given host" do
           Puppet::Run.indirection.expects(:save).with(@agent_run, 'https://host:8139/production/run/host').returns(@agent_run)
 
           @kick.run_for_host('host')
         end
 
         it "should exit the child with 0 on success" do
           @agent_run.stubs(:status).returns("success")
 
           @kick.expects(:exit).with(0)
 
           @kick.run_for_host('host')
         end
 
         it "should exit the child with 3 on running" do
           @agent_run.stubs(:status).returns("running")
 
           @kick.expects(:exit).with(3)
 
           @kick.run_for_host('host')
         end
 
         it "should exit the child with 12 on unknown answer" do
           @agent_run.stubs(:status).returns("whatever")
 
           @kick.expects(:exit).with(12)
 
           @kick.run_for_host('host')
         end
       end
     end
   end
 end
diff --git a/spec/unit/application/master_spec.rb b/spec/unit/application/master_spec.rb
index ea5d3f518..2a24086f3 100755
--- a/spec/unit/application/master_spec.rb
+++ b/spec/unit/application/master_spec.rb
@@ -1,410 +1,404 @@
 #!/usr/bin/env rspec
 require '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.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
     Puppet::Node::Facts.indirection.stubs(:terminus_class=)
     Puppet::Node::Facts.indirection.stubs(:cache_class=)
     Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
     Puppet::SSL::Host.stubs(:ca_location=)
   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 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
+      Puppet::Log.level.should == :debug
     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
+      Puppet::Log.level.should == :info
     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,:master and :metrics category" do
       Puppet.settings.expects(:use).with(:main,:master,:ssl,:metrics)
 
       @master.setup
     end
 
     it "should cache class in yaml" do
       Puppet::Node.indirection.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 compile if called with --compile" do
       @master.options[:node] = "foo"
       @master.expects(:compile)
       @master.run_command
     end
 
     it "should dispatch to main otherwise" do
       @master.options[:node] = nil
 
       @master.expects(:main)
       @master.run_command
     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.indirection.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.indirection.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.indirection.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.indirection.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", :if => Puppet.features.rack? do
         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
diff --git a/spec/unit/application/queue_spec.rb b/spec/unit/application/queue_spec.rb
index 87713ca97..d71c879a9 100755
--- a/spec/unit/application/queue_spec.rb
+++ b/spec/unit/application/queue_spec.rb
@@ -1,182 +1,177 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/queue'
 require 'puppet/indirector/catalog/queue'
 
 describe Puppet::Application::Queue do
   before :each do
     @queue = Puppet::Application[:queue]
     @queue.stubs(:puts)
     @daemon = stub_everything 'daemon', :daemonize => nil
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
 
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @queue.should_parse_config?.should be_true
   end
 
   it "should declare a main command" do
     @queue.should respond_to(:main)
   end
 
   it "should declare a preinit block" do
     @queue.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     it "should catch INT" do
       Signal.expects(:trap).with { |arg,block| arg == :INT }
 
       @queue.preinit
     end
 
     it "should init :verbose to false" do
       @queue.preinit
 
       @queue.options[:verbose].should be_false
     end
 
     it "should init :debug to false" do
       @queue.preinit
 
       @queue.options[:debug].should be_false
     end
 
     it "should create a Daemon instance and copy ARGV to it" do
       ARGV.expects(:dup).returns "eh"
       daemon = mock("daemon")
       daemon.expects(:argv=).with("eh")
       Puppet::Daemon.expects(:new).returns daemon
       @queue.preinit
     end
   end
 
   describe "when handling options" do
 
     [:debug, :verbose].each do |option|
       it "should declare handle_#{option} method" do
         @queue.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @queue.options.expects(:[]=).with(option, 'arg')
         @queue.send("handle_#{option}".to_sym, 'arg')
       end
     end
   end
 
   describe "during setup" do
     before :each do
       @queue.options.stubs(:[])
       @queue.daemon.stubs(:daemonize)
       Puppet.stubs(:info)
       Puppet.features.stubs(:stomp?).returns true
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
       Puppet.stubs(:settraps)
       Puppet.settings.stubs(:print_config?)
       Puppet.settings.stubs(:print_config)
     end
 
     it "should fail if the stomp feature is missing" do
       Puppet.features.expects(:stomp?).returns false
       lambda { @queue.setup }.should raise_error(ArgumentError)
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @queue.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @queue.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @queue.setup }.should raise_error(SystemExit)
     end
 
     it "should call setup_logs" do
       @queue.expects(:setup_logs)
       @queue.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
         @queue.options.stubs(:[]).with(:debug).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:debug)
-
         @queue.setup_logs
+        Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose was passed" do
         @queue.options.stubs(:[]).with(:verbose).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:info)
-
         @queue.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
           @queue.options.stubs(:[]).with(level).returns(true)
 
           Puppet::Util::Log.expects(:newdestination).with(:console)
 
           @queue.setup_logs
         end
       end
     end
 
     it "should configure the Catalog class to use ActiveRecord" do
       Puppet::Resource::Catalog.indirection.expects(:terminus_class=).with(:active_record)
 
       @queue.setup
     end
 
     it "should daemonize if needed" do
       Puppet.expects(:[]).with(:daemonize).returns(true)
 
       @queue.daemon.expects(:daemonize)
 
       @queue.setup
     end
   end
 
   describe "when running" do
     before :each do
       @queue.stubs(:sleep_forever)
       Puppet::Resource::Catalog::Queue.stubs(:subscribe)
       Thread.list.each { |t| t.stubs(:join) }
     end
 
     it "should subscribe to the queue" do
       Puppet::Resource::Catalog::Queue.expects(:subscribe)
       @queue.main
     end
 
     it "should log and save each catalog passed by the queue" do
       catalog = Puppet::Resource::Catalog.new('eh')
       Puppet::Resource::Catalog.indirection.expects(:save).with(catalog)
 
       Puppet::Resource::Catalog::Queue.expects(:subscribe).yields(catalog)
       Puppet.expects(:notice).times(2)
       @queue.main
     end
 
     it "should join all of the running threads" do
       Thread.list.each { |t| t.expects(:join) }
       @queue.main
     end
   end
 end
diff --git a/spec/unit/application/resource_spec.rb b/spec/unit/application/resource_spec.rb
index 673bd65d7..af60f12c1 100755
--- a/spec/unit/application/resource_spec.rb
+++ b/spec/unit/application/resource_spec.rb
@@ -1,232 +1,226 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/resource'
 
 describe Puppet::Application::Resource do
   before :each do
     @resource = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
     Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
     @resource.should_parse_config?.should be_false
   end
 
   it "should declare a main command" do
     @resource.should respond_to(:main)
   end
 
   it "should declare a host option" do
     @resource.should respond_to(:handle_host)
   end
 
   it "should declare a types option" do
     @resource.should respond_to(:handle_types)
   end
 
   it "should declare a param option" do
     @resource.should respond_to(:handle_param)
   end
 
   it "should declare a preinit block" do
     @resource.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     it "should set hosts to nil" do
       @resource.preinit
 
       @resource.host.should be_nil
     end
 
     it "should init extra_params to empty array" do
       @resource.preinit
 
       @resource.extra_params.should == []
     end
 
     it "should load Facter facts" do
       Facter.expects(:loadfacts).once
       @resource.preinit
     end
   end
 
   describe "when handling options" do
 
     [:debug, :verbose, :edit].each do |option|
       it "should declare handle_#{option} method" do
         @resource.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @resource.options.expects(:[]=).with(option, 'arg')
         @resource.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set options[:host] to given host" do
       @resource.handle_host(:whatever)
 
       @resource.host.should == :whatever
     end
 
     it "should load an display all types with types option" do
       type1 = stub_everything 'type1', :name => :type1
       type2 = stub_everything 'type2', :name => :type2
       Puppet::Type.stubs(:loadall)
       Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
       @resource.stubs(:exit)
 
       @resource.expects(:puts).with(['type1','type2'])
       @resource.handle_types(nil)
     end
 
     it "should add param to extra_params list" do
       @resource.extra_params = [ :param1 ]
       @resource.handle_param("whatever")
 
       @resource.extra_params.should == [ :param1, :whatever ]
     end
   end
 
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
     end
 
 
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @resource.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @resource.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @resource.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @resource.options.stubs(:[]).with(:debug).returns(false)
       @resource.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @resource.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
       @resource.setup
     end
   end
 
   describe "when running" do
 
     before :each do
       @type = stub_everything 'type', :properties => []
       @resource.command_line.stubs(:args).returns(['type'])
       Puppet::Type.stubs(:type).returns(@type)
     end
 
     it "should raise an error if no type is given" do
       @resource.command_line.stubs(:args).returns([])
       lambda { @resource.main }.should raise_error
     end
 
     it "should raise an error when editing a remote host" do
       @resource.options.stubs(:[]).with(:edit).returns(true)
       @resource.host = 'host'
 
       lambda { @resource.main }.should raise_error
     end
 
     it "should raise an error if the type is not found" do
       Puppet::Type.stubs(:type).returns(nil)
 
       lambda { @resource.main }.should raise_error
     end
 
     describe "with a host" do
       before :each do
         @resource.stubs(:puts)
         @resource.host = 'host'
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
         @resource.command_line.stubs(:args).returns(['type'])
         Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
         @resource.main
       end
 
       it "should describe the given resource" do
         @resource.command_line.stubs(:args).returns(['type', 'name'])
         x = stub_everything 'resource'
         Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(x)
         @resource.main
       end
 
       it "should add given parameters to the object" do
         @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
 
         res = stub "resource"
         Puppet::Resource.indirection.expects(:save).with(res, 'https://host:8139/production/resources/type/name').returns(res)
         res.expects(:collect)
         res.expects(:to_manifest)
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
 
         @resource.main
       end
 
     end
 
     describe "without a host" do
       before :each do
         @resource.stubs(:puts)
         @resource.host = nil
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
         Puppet::Resource.indirection.expects(:search).with('type/', {}).returns([])
         @resource.main
       end
 
       it "should describe the given resource" do
         @resource.command_line.stubs(:args).returns(['type','name'])
         x = stub_everything 'resource'
         Puppet::Resource.indirection.expects(:find).with('type/name').returns(x)
         @resource.main
       end
 
       it "should add given parameters to the object" do
         @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
 
         res = stub "resource"
         Puppet::Resource.indirection.expects(:save).with(res, 'type/name').returns(res)
         res.expects(:collect)
         res.expects(:to_manifest)
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
 
         @resource.main
       end
 
     end
   end
 end
diff --git a/spec/unit/application_spec.rb b/spec/unit/application_spec.rb
index f46959092..de1ca1257 100755
--- a/spec/unit/application_spec.rb
+++ b/spec/unit/application_spec.rb
@@ -1,609 +1,607 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application'
 require 'puppet'
 require 'getoptlong'
 
 describe Puppet::Application do
 
   before do
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
     @app.stubs(:name).returns("test_app")
     # avoid actually trying to parse any settings
     Puppet.settings.stubs(:parse)
   end
 
   describe "finding" do
     before do
       @klass = Puppet::Application
       @klass.stubs(:puts)
     end
 
     it "should find classes in the namespace" do
       @klass.find("Agent").should == @klass::Agent
     end
 
     it "should not find classes outside the namespace" do
       lambda { @klass.find("String") }.should raise_error(SystemExit)
     end
 
     it "should exit if it can't find a class" do
       lambda { @klass.find("ThisShallNeverEverEverExistAsdf") }.should raise_error(SystemExit)
     end
   end
 
   describe ".run_mode" do
     it "should default to user" do
       @appclass.run_mode.name.should == :user
     end
 
     it "should set and get a value" do
       @appclass.run_mode :agent
       @appclass.run_mode.name.should == :agent
     end
   end
 
   it "should sadly and frighteningly allow run_mode to change at runtime" do
     class TestApp < Puppet::Application
       run_mode :master
       def run_command
         # This is equivalent to calling these methods externally to the
         # instance, but since this is what "real world" code is likely to do
         # (and we need the class anyway) we may as well test that. --daniel 2011-02-03
         set_run_mode self.class.run_mode "agent"
       end
     end
 
     Puppet[:run_mode].should == "user"
 
     expect {
       app = TestApp.new
 
       Puppet[:run_mode].should == "master"
 
       app.run
 
       app.class.run_mode.name.should == :agent
       $puppet_application_mode.name.should == :agent
     }.should_not raise_error
 
     Puppet[:run_mode].should == "agent"
   end
 
   it "it should not allow run mode to be set multiple times" do
     pending "great floods of tears, you can do this right now" # --daniel 2011-02-03
     app = Puppet::Application.new
     expect {
       app.set_run_mode app.class.run_mode "master"
       $puppet_application_mode.name.should == :master
       app.set_run_mode app.class.run_mode "agent"
       $puppet_application_mode.name.should == :agent
     }.should raise_error
   end
 
   it "should explode when an invalid run mode is set at runtime, for great victory"
   # ...but you can, and while it will explode, that only happens too late for
   # us to easily test. --daniel 2011-02-03
 
   it "should have a run entry-point" do
     @app.should respond_to(:run)
   end
 
   it "should have a read accessor to options" do
     @app.should respond_to(:options)
   end
 
   it "should include a default setup method" do
     @app.should respond_to(:setup)
   end
 
   it "should include a default preinit method" do
     @app.should respond_to(:preinit)
   end
 
   it "should include a default run_command method" do
     @app.should respond_to(:run_command)
   end
 
   it "should invoke main as the default" do
     @app.expects( :main )
     @app.run_command
   end
 
   describe 'when invoking clear!' do
     before :each do
       Puppet::Application.run_status = :stop_requested
       Puppet::Application.clear!
     end
 
     it 'should have nil run_status' do
       Puppet::Application.run_status.should be_nil
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return false for interrupted?' do
       Puppet::Application.interrupted?.should be_false
     end
 
     it 'should return true for clear?' do
       Puppet::Application.clear?.should be_true
     end
   end
 
   describe 'after invoking stop!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.stop!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :stop_requested' do
       Puppet::Application.run_status.should == :stop_requested
     end
 
     it 'should return true for stop_requested?' do
       Puppet::Application.stop_requested?.should be_true
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when invoking restart!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.restart!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :restart_requested' do
       Puppet::Application.run_status.should == :restart_requested
     end
 
     it 'should return true for restart_requested?' do
       Puppet::Application.restart_requested?.should be_true
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when performing a controlled_run' do
     it 'should not execute block if not :clear?' do
       Puppet::Application.run_status = :stop_requested
       target = mock 'target'
       target.expects(:some_method).never
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     it 'should execute block if :clear?' do
       Puppet::Application.run_status = nil
       target = mock 'target'
       target.expects(:some_method).once
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     describe 'on POSIX systems', :if => Puppet.features.posix? do
       it 'should signal process with HUP after block if restart requested during block execution' do
         Puppet::Application.run_status = nil
         target = mock 'target'
         target.expects(:some_method).once
         old_handler = trap('HUP') { target.some_method }
         begin
           Puppet::Application.controlled_run do
             Puppet::Application.run_status = :restart_requested
           end
         ensure
           trap('HUP', old_handler)
         end
       end
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
   end
 
   describe "when parsing command-line options" do
 
     before :each do
       @app.command_line.stubs(:args).returns([])
 
       Puppet.settings.stubs(:optparse_addargs).returns([])
     end
 
     it "should pass the banner to the option parser" do
       option_parser = stub "option parser"
       option_parser.stubs(:on)
       option_parser.stubs(:parse!)
       @app.class.instance_eval do
         banner "banner"
       end
 
       OptionParser.expects(:new).with("banner").returns(option_parser)
 
       @app.parse_options
     end
 
     it "should get options from Puppet.settings.optparse_addargs" do
       Puppet.settings.expects(:optparse_addargs).returns([])
 
       @app.parse_options
     end
 
     it "should add Puppet.settings options to OptionParser" do
       Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option"]])
       Puppet.settings.expects(:handlearg).with("--option", 'true')
       @app.command_line.stubs(:args).returns(["--option"])
       @app.parse_options
     end
 
     it "should ask OptionParser to parse the command-line argument" do
       @app.command_line.stubs(:args).returns(%w{ fake args })
       OptionParser.any_instance.expects(:parse!).with(%w{ fake args })
 
       @app.parse_options
     end
 
     describe "when using --help" do
 
       it "should call exit" do
         @app.expects(:exit)
         @app.stubs(:puts)
 
         @app.handle_help(nil)
       end
 
     end
 
     describe "when using --version" do
       it "should declare a version option" do
         @app.should respond_to(:handle_version)
       end
 
       it "should exit after printing the version" do
         @app.stubs(:puts)
 
         lambda { @app.handle_version(nil) }.should raise_error(SystemExit)
       end
     end
 
     describe "when dealing with an argument not declared directly by the application" do
       it "should pass it to handle_unknown if this method exists" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled", :REQUIRED]])
 
         @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
         @app.command_line.stubs(:args).returns(["--not-handled", "value"])
         @app.parse_options
       end
 
       it "should pass it to Puppet.settings if handle_unknown says so" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
 
         @app.stubs(:handle_unknown).with("--topuppet", "value").returns(false)
 
         Puppet.settings.expects(:handlearg).with("--topuppet", "value")
         @app.command_line.stubs(:args).returns(["--topuppet", "value"])
         @app.parse_options
       end
 
       it "should pass it to Puppet.settings if there is no handle_unknown method" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
 
         @app.stubs(:respond_to?).returns(false)
 
         Puppet.settings.expects(:handlearg).with("--topuppet", "value")
         @app.command_line.stubs(:args).returns(["--topuppet", "value"])
         @app.parse_options
       end
 
       it "should transform boolean false value to string for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "false")
         @app.handlearg("--option", false)
       end
 
       it "should transform boolean true value to string for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "true")
         @app.handlearg("--option", true)
       end
 
       it "should transform boolean option to normal form for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "true")
         @app.handlearg("--[no-]option", true)
       end
 
       it "should transform boolean option to no- form for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--no-option", "false")
         @app.handlearg("--[no-]option", false)
       end
 
     end
   end
 
   describe "when calling default setup" do
 
     before :each do
       @app.stubs(:should_parse_config?).returns(false)
       @app.options.stubs(:[])
     end
 
     [ :debug, :verbose ].each do |level|
       it "should honor option #{level}" do
         @app.options.stubs(:[]).with(level).returns(true)
         Puppet::Util::Log.stubs(:newdestination)
-
-        Puppet::Util::Log.expects(:level=).with(level == :verbose ? :info : :debug)
-
         @app.setup
+        Puppet::Util::Log.level.should == (level == :verbose ? :info : :debug)
       end
     end
 
     it "should honor setdest option" do
       @app.options.stubs(:[]).with(:setdest).returns(false)
 
       Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
       @app.setup
     end
 
   end
 
   describe "when configuring routes" do
     include PuppetSpec::Files
 
     before :each do
       Puppet::Node.indirection.reset_terminus_class
     end
 
     after :each do
       Puppet::Node.indirection.reset_terminus_class
     end
 
     it "should use the routes specified for only the active application" do
       Puppet[:route_file] = tmpfile('routes')
       File.open(Puppet[:route_file], 'w') do |f|
         f.print <<-ROUTES
           test_app:
             node:
               terminus: exec
           other_app:
             node:
               terminus: plain
             catalog:
               terminus: invalid
         ROUTES
       end
 
       @app.configure_indirector_routes
 
       Puppet::Node.indirection.terminus_class.should == 'exec'
     end
 
     it "should not fail if the route file doesn't exist" do
       Puppet[:route_file] = "/dev/null/non-existent"
 
       expect { @app.configure_indirector_routes }.should_not raise_error
     end
 
     it "should raise an error if the routes file is invalid" do
       Puppet[:route_file] = tmpfile('routes')
       File.open(Puppet[:route_file], 'w') do |f|
         f.print <<-ROUTES
          invalid : : yaml
         ROUTES
       end
 
       expect { @app.configure_indirector_routes }.should raise_error
     end
   end
 
   describe "when running" do
 
     before :each do
       @app.stubs(:preinit)
       @app.stubs(:setup)
       @app.stubs(:parse_options)
     end
 
     it "should call preinit" do
       @app.stubs(:run_command)
 
       @app.expects(:preinit)
 
       @app.run
     end
 
     it "should call parse_options" do
       @app.stubs(:run_command)
 
       @app.expects(:parse_options)
 
       @app.run
     end
 
     it "should call run_command" do
 
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should parse Puppet configuration if should_parse_config is called" do
       @app.stubs(:run_command)
       @app.class.should_parse_config
 
       Puppet.settings.expects(:parse)
 
       @app.run
     end
 
     it "should not parse_option if should_not_parse_config is called" do
       @app.stubs(:run_command)
       @app.class.should_not_parse_config
 
       Puppet.settings.expects(:parse).never
 
       @app.run
     end
 
     it "should parse Puppet configuration if needed" do
       @app.stubs(:run_command)
       @app.stubs(:should_parse_config?).returns(true)
 
       Puppet.settings.expects(:parse)
 
       @app.run
     end
 
     it "should call run_command" do
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should call main as the default command" do
       @app.expects(:main)
 
       @app.run
     end
 
     it "should warn and exit if no command can be called" do
       $stderr.expects(:puts)
       @app.expects(:exit).with(1)
       @app.run
     end
 
     it "should raise an error if dispatch returns no command" do
       @app.stubs(:get_command).returns(nil)
       $stderr.expects(:puts)
       @app.expects(:exit).with(1)
       @app.run
     end
 
     it "should raise an error if dispatch returns an invalid command" do
       @app.stubs(:get_command).returns(:this_function_doesnt_exist)
       $stderr.expects(:puts)
       @app.expects(:exit).with(1)
       @app.run
     end
   end
 
   describe "when metaprogramming" do
 
     describe "when calling option" do
       it "should create a new method named after the option" do
         @app.class.option("--test1","-t") do
         end
 
         @app.should respond_to(:handle_test1)
       end
 
       it "should transpose in option name any '-' into '_'" do
         @app.class.option("--test-dashes-again","-t") do
         end
 
         @app.should respond_to(:handle_test_dashes_again)
       end
 
       it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
         @app.class.option("--[no-]test2","-t") do
         end
 
         @app.should respond_to(:handle_test2)
       end
 
       describe "when a block is passed" do
         it "should create a new method with it" do
           @app.class.option("--[no-]test2","-t") do
             raise "I can't believe it, it works!"
           end
 
           lambda { @app.handle_test2 }.should raise_error
         end
 
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
 
           @app.class.option("--[no-]test3","-t") do
           end
 
           @app.parse_options
         end
 
         it "should pass a block that calls our defined method" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with('--test4','-t').yields(nil)
 
           @app.expects(:send).with(:handle_test4, nil)
 
           @app.class.option("--test4","-t") do
           end
 
           @app.parse_options
         end
       end
 
       describe "when no block is given" do
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with("--test4","-t")
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
 
         it "should give to OptionParser a block that adds the the value to the options array" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
 
           @app.options.expects(:[]=).with(:test4,nil)
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
       end
     end
 
   end
 end
diff --git a/spec/unit/interface/action_spec.rb b/spec/unit/interface/action_spec.rb
index 0eb450ee2..24826a6ef 100755
--- a/spec/unit/interface/action_spec.rb
+++ b/spec/unit/interface/action_spec.rb
@@ -1,392 +1,448 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/interface/action'
 
 describe Puppet::Interface::Action do
   describe "when validating the action name" do
     [nil, '', 'foo bar', '-foobar'].each do |input|
       it "should treat #{input.inspect} as an invalid name" do
         expect { Puppet::Interface::Action.new(nil, input) }.
           should raise_error(/is an invalid action name/)
       end
     end
   end
 
+  describe "#when_invoked=" do
+    it "should fail if the block has arity 0" do
+      pending "Ruby 1.8 (painfully) treats argument-free blocks as arity -1" if
+        RUBY_VERSION =~ /^1\.8/
+
+      expect {
+        Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+          action :foo do
+            when_invoked do
+            end
+          end
+        end
+      }.to raise_error ArgumentError, /foobra/
+    end
+
+    it "should work with arity 1 blocks" do
+      face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+        action :foo do
+          when_invoked {|one| }
+        end
+      end
+      # -1, because we use option defaulting. :(
+      face.method(:foo).arity.should == -1
+    end
+
+    it "should work with arity 2 blocks" do
+      face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+        action :foo do
+          when_invoked {|one, two| }
+        end
+      end
+      # -2, because we use option defaulting. :(
+      face.method(:foo).arity.should == -2
+    end
+
+    it "should work with arity 1 blocks that collect arguments" do
+      face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+        action :foo do
+          when_invoked {|*one| }
+        end
+      end
+      # -1, because we use only varargs
+      face.method(:foo).arity.should == -1
+    end
+
+    it "should work with arity 2 blocks that collect arguments" do
+      face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+        action :foo do
+          when_invoked {|one, *two| }
+        end
+      end
+      # -2, because we take one mandatory argument, and one varargs
+      face.method(:foo).arity.should == -2
+    end
+  end
+
   describe "when invoking" do
     it "should be able to call other actions on the same object" do
       face = Puppet::Interface.new(:my_face, '0.0.1') do
         action(:foo) do
           when_invoked { 25 }
         end
 
         action(:bar) do
           when_invoked { "the value of foo is '#{foo}'" }
         end
       end
       face.foo.should == 25
       face.bar.should == "the value of foo is '25'"
     end
 
     # bar is a class action calling a class action
     # quux is a class action calling an instance action
     # baz is an instance action calling a class action
     # qux is an instance action calling an instance action
     it "should be able to call other actions on the same object when defined on a class" do
       class Puppet::Interface::MyInterfaceBaseClass < Puppet::Interface
         action(:foo) do
           when_invoked { 25 }
         end
 
         action(:bar) do
           when_invoked { "the value of foo is '#{foo}'" }
         end
 
         action(:quux) do
           when_invoked { "qux told me #{qux}" }
         end
       end
 
       face = Puppet::Interface::MyInterfaceBaseClass.new(:my_inherited_face, '0.0.1') do
         action(:baz) do
           when_invoked { "the value of foo in baz is '#{foo}'" }
         end
 
         action(:qux) do
           when_invoked { baz }
         end
       end
       face.foo.should  == 25
       face.bar.should  == "the value of foo is '25'"
       face.quux.should == "qux told me the value of foo in baz is '25'"
       face.baz.should  == "the value of foo in baz is '25'"
       face.qux.should  == "the value of foo in baz is '25'"
     end
 
     context "when calling the Ruby API" do
       let :face do
         Puppet::Interface.new(:ruby_api, '1.0.0') do
           action :bar do
             when_invoked do |*args|
               args.last
             end
           end
         end
       end
 
       it "should work when no options are supplied" do
         options = face.bar
         options.should == {}
       end
 
       it "should work when options are supplied" do
         options = face.bar(:bar => "beer")
         options.should == { :bar => "beer" }
       end
 
       it "should call #validate_args on the action when invoked" do
         face.get_action(:bar).expects(:validate_args).with([1, :two, 'three', {}])
         face.bar 1, :two, 'three'
       end
     end
   end
 
   describe "with action-level options" do
     it "should support options with an empty block" do
       face = Puppet::Interface.new(:action_level_options, '0.0.1') do
         action :foo do
           option "--bar" do
             # this line left deliberately blank
           end
         end
       end
 
       face.should_not be_option :bar
       face.get_action(:foo).should be_option :bar
     end
 
     it "should return only action level options when there are no face options" do
       face = Puppet::Interface.new(:action_level_options, '0.0.1') do
         action :foo do option "--bar" end
       end
 
       face.get_action(:foo).options.should =~ [:bar]
     end
 
     describe "with both face and action options" do
       let :face do
         Puppet::Interface.new(:action_level_options, '0.0.1') do
           action :foo do option "--bar" end
           action :baz do option "--bim" end
           option "--quux"
         end
       end
 
       it "should return combined face and action options" do
         face.get_action(:foo).options.should =~ [:bar, :quux]
       end
 
       it "should fetch options that the face inherited" do
         parent = Class.new(Puppet::Interface)
         parent.option "--foo"
         child = parent.new(:inherited_options, '0.0.1') do
           option "--bar"
           action :action do option "--baz" end
         end
 
         action = child.get_action(:action)
         action.should be
 
         [:baz, :bar, :foo].each do |name|
           action.get_option(name).should be_an_instance_of Puppet::Interface::Option
         end
       end
 
       it "should get an action option when asked" do
         face.get_action(:foo).get_option(:bar).
           should be_an_instance_of Puppet::Interface::Option
       end
 
       it "should get a face option when asked" do
         face.get_action(:foo).get_option(:quux).
           should be_an_instance_of Puppet::Interface::Option
       end
 
       it "should return options only for this action" do
         face.get_action(:baz).options.should =~ [:bim, :quux]
       end
     end
 
     it_should_behave_like "things that declare options" do
       def add_options_to(&block)
         face = Puppet::Interface.new(:with_options, '0.0.1') do
           action(:foo, &block)
         end
         face.get_action(:foo)
       end
     end
 
     it "should fail when a face option duplicates an action option" do
       expect {
         Puppet::Interface.new(:action_level_options, '0.0.1') do
           option "--foo"
           action :bar do option "--foo" end
         end
       }.should raise_error ArgumentError, /Option foo conflicts with existing option foo/i
     end
 
     it "should fail when a required action option is not provided" do
       face = Puppet::Interface.new(:required_action_option, '0.0.1') do
         action(:bar) do
           option('--foo') { required }
           when_invoked { }
         end
       end
       expect { face.bar }.to raise_error ArgumentError, /missing required options \(foo\)/
     end
 
     it "should fail when a required face option is not provided" do
       face = Puppet::Interface.new(:required_face_option, '0.0.1') do
         option('--foo') { required }
         action(:bar) { when_invoked { } }
       end
       expect { face.bar }.to raise_error ArgumentError, /missing required options \(foo\)/
     end
   end
 
   context "with action decorators" do
     context "local only" do
       let :face do
         Puppet::Interface.new(:action_decorators, '0.0.1') do
           action :bar do when_invoked do true end end
           def report(arg) end
         end
       end
 
       it "should call action before decorators" do
         face.action(:baz) do
           option "--baz" do
             before_action do |action, args, options|
               report(:action_option)
             end
           end
           when_invoked do true end
         end
 
         face.expects(:report).with(:action_option)
         face.baz :baz => true
       end
 
       it "should call action after decorators" do
         face.action(:baz) do
           option "--baz" do
             after_action do |action, args, options|
               report(:action_option)
             end
           end
           when_invoked do true end
         end
 
         face.expects(:report).with(:action_option)
         face.baz :baz => true
       end
 
       it "should call local before decorators" do
         face.option "--foo FOO" do
           before_action do |action, args, options|
             report(:before)
           end
         end
         face.expects(:report).with(:before)
         face.bar({:foo => 12})
       end
 
       it "should call local after decorators" do
         face.option "--foo FOO" do
           after_action do |action, args, options| report(:after) end
         end
         face.expects(:report).with(:after)
         face.bar({:foo => 12})
       end
 
       context "with inactive decorators" do
         it "should not invoke a decorator if the options are empty" do
           face.option "--foo FOO" do
             before_action do |action, args, options|
               report :before_action
             end
           end
           face.expects(:report).never # I am testing the negative.
           face.bar
         end
 
         context "with some decorators only" do
           before :each do
             face.option "--foo" do
               before_action do |action, args, options| report :foo end
             end
             face.option "--bar" do
               before_action do |action, args, options| report :bar end
             end
           end
 
           it "should work with the foo option" do
             face.expects(:report).with(:foo)
             face.bar(:foo => true)
           end
 
           it "should work with the bar option" do
             face.expects(:report).with(:bar)
             face.bar(:bar => true)
           end
 
           it "should work with both options" do
             face.expects(:report).with(:foo)
             face.expects(:report).with(:bar)
             face.bar(:foo => true, :bar => true)
           end
         end
       end
     end
 
     context "with inherited decorators" do
       let :parent do
         parent = Class.new(Puppet::Interface)
         parent.script :on_parent do :on_parent end
         parent.define_method :report do |arg| arg end
         parent
       end
 
       let :child do
         child = parent.new(:inherited_decorators, '0.0.1') do
           script :on_child do :on_child end
         end
       end
 
       context "with a child decorator" do
         subject do
           child.option "--foo FOO" do
             before_action do |action, args, options|
               report(:child_before)
             end
           end
           child.expects(:report).with(:child_before)
           child
         end
 
         it "child actions should invoke the decorator" do
           subject.on_child({:foo => true, :bar => true}).should == :on_child
         end
 
         it "parent actions should invoke the decorator" do
           subject.on_parent({:foo => true, :bar => true}).should == :on_parent
         end
       end
 
       context "with a parent decorator" do
         subject do
           parent.option "--foo FOO" do
             before_action do |action, args, options|
               report(:parent_before)
             end
           end
           child.expects(:report).with(:parent_before)
           child
         end
 
         it "child actions should invoke the decorator" do
           subject.on_child({:foo => true, :bar => true}).should == :on_child
         end
 
         it "parent actions should invoke the decorator" do
           subject.on_parent({:foo => true, :bar => true}).should == :on_parent
         end
       end
 
       context "with child and parent decorators" do
         subject do
           parent.option "--foo FOO" do
             before_action { |action, args, options| report(:parent_before) }
             after_action  { |action, args, options| report(:parent_after)  }
           end
           child.option "--bar BAR" do
             before_action { |action, args, options| report(:child_before) }
             after_action  { |action, args, options| report(:child_after)  }
           end
 
           child.expects(:report).with(:child_before)
           child.expects(:report).with(:parent_before)
           child.expects(:report).with(:parent_after)
           child.expects(:report).with(:child_after)
 
           child
         end
 
         it "child actions should invoke all the decorator" do
           subject.on_child({:foo => true, :bar => true}).should == :on_child
         end
 
         it "parent actions should invoke all the decorator" do
           subject.on_parent({:foo => true, :bar => true}).should == :on_parent
         end
       end
     end
   end
 
   it_should_behave_like "documentation on faces" do
     subject do
       face = Puppet::Interface.new(:action_documentation, '0.0.1') do
         action :documentation do end
       end
       face.get_action(:documentation)
     end
   end
 
   context "#when_rendering" do
     it "should fail if no type is given when_rendering"
     it "should accept a when_rendering block"
     it "should accept multiple when_rendering blocks"
     it "should fail if when_rendering gets a non-symbol identifier"
     it "should fail if a second block is given for the same type"
     it "should return the block if asked"
   end
 end
diff --git a/spec/unit/interface/face_collection_spec.rb b/spec/unit/interface/face_collection_spec.rb
index f9498cbb8..890e06a9e 100755
--- a/spec/unit/interface/face_collection_spec.rb
+++ b/spec/unit/interface/face_collection_spec.rb
@@ -1,166 +1,162 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'tmpdir'
 require 'puppet/interface/face_collection'
 
 describe Puppet::Interface::FaceCollection do
   # To avoid cross-pollution we have to save and restore both the hash
   # containing all the interface data, and the array used by require.  Restoring
   # both means that we don't leak side-effects across the code. --daniel 2011-04-06
   #
   # Worse luck, we *also* need to flush $" of anything defining a face,
   # because otherwise we can cross-pollute from other test files and end up
   # with no faces loaded, but the require value set true. --daniel 2011-04-10
   before :each do
     @original_faces    = subject.instance_variable_get("@faces").dup
     @original_required = $".dup
     $".delete_if do |path| path =~ %r{/face/.*\.rb$} end
     subject.instance_variable_get("@faces").clear
   end
 
   after :each do
     subject.instance_variable_set("@faces", @original_faces)
     $".clear ; @original_required.each do |item| $" << item end
   end
 
-  describe "::validate_version" do
-    it 'should permit three number versions' do
-      subject.validate_version('10.10.10').should == true
-    end
-
-    it 'should permit versions with appended descriptions' do
-      subject.validate_version('10.10.10beta').should == true
-    end
-
-    it 'should not permit versions with more than three numbers' do
-      subject.validate_version('1.2.3.4').should == false
-    end
-
-    it 'should not permit versions with only two numbers' do
-      subject.validate_version('10.10').should == false
-    end
-
-    it 'should not permit versions with only one number' do
-      subject.validate_version('123').should == false
+  describe "::prefix_match?" do
+    #   want     have
+    { ['1.0.0', '1.0.0'] => true,
+      ['1.0',   '1.0.0'] => true,
+      ['1',     '1.0.0'] => true,
+      ['1.0.0', '1.1.0'] => false,
+      ['1.0',   '1.1.0'] => false,
+      ['1',     '1.1.0'] => true,
+      ['1.0.1', '1.0.0'] => false,
+    }.each do |data, result|
+      it "should return #{result.inspect} for prefix_match?(#{data.join(', ')})" do
+        subject.prefix_match?(*data).should == result
+      end
     end
+  end
 
-    it 'should not permit versions with text in any position but at the end' do
-      subject.validate_version('v1.1.1').should == false
+  describe "::validate_version" do
+    { '10.10.10'     => true,
+      '1.2.3.4'      => false,
+      '10.10.10beta' => true,
+      '10.10'        => false,
+      '123'          => false,
+      'v1.1.1'       => false,
+    }.each do |input, result|
+      it "should#{result ? '' : ' not'} permit #{input.inspect}" do
+        subject.validate_version(input).should(result ? be_true : be_false)
+      end
     end
   end
 
   describe "::[]" do
     before :each do
       subject.instance_variable_get("@faces")[:foo]['0.0.1'] = 10
     end
 
     it "should return the face with the given name" do
       subject["foo", '0.0.1'].should == 10
     end
 
     it "should attempt to load the face if it isn't found" do
       subject.expects(:require).with('puppet/face/bar')
       subject["bar", '0.0.1']
     end
 
     it "should attempt to load the default face for the specified version :current" do
       subject.expects(:require).with('puppet/face/fozzie')
       subject['fozzie', :current]
     end
-  end
 
-  describe "::face?" do
     it "should return true if the face specified is registered" do
       subject.instance_variable_get("@faces")[:foo]['0.0.1'] = 10
-      subject.face?("foo", '0.0.1').should == true
+      subject["foo", '0.0.1'].should == 10
     end
 
     it "should attempt to require the face if it is not registered" do
       subject.expects(:require).with do |file|
         subject.instance_variable_get("@faces")[:bar]['0.0.1'] = true
         file == 'puppet/face/bar'
       end
-      subject.face?("bar", '0.0.1').should == true
-    end
-
-    it "should return true if requiring the face registered it" do
-      subject.stubs(:require).with do
-        subject.instance_variable_get("@faces")[:bar]['0.0.1'] = 20
-      end
+      subject["bar", '0.0.1'].should be_true
     end
 
     it "should return false if the face is not registered" do
       subject.stubs(:require).returns(true)
-      subject.face?("bar", '0.0.1').should be_false
+      subject["bar", '0.0.1'].should be_false
     end
 
     it "should return false if the face file itself is missing" do
       subject.stubs(:require).
         raises(LoadError, 'no such file to load -- puppet/face/bar')
-      subject.face?("bar", '0.0.1').should be_false
+      subject["bar", '0.0.1'].should be_false
     end
 
     it "should register the version loaded by `:current` as `:current`" do
       subject.expects(:require).with do |file|
         subject.instance_variable_get("@faces")[:huzzah]['2.0.1'] = :huzzah_face
         file == 'puppet/face/huzzah'
       end
-      subject.face?("huzzah", :current)
+      subject["huzzah", :current]
       subject.instance_variable_get("@faces")[:huzzah][:current].should == :huzzah_face
     end
 
     context "with something on disk" do
       it "should register the version loaded from `puppet/face/{name}` as `:current`" do
-        subject.should be_face "huzzah", '2.0.1'
-        subject.should be_face "huzzah", :current
+        subject["huzzah", '2.0.1'].should be
+        subject["huzzah", :current].should be
         Puppet::Face[:huzzah, '2.0.1'].should == Puppet::Face[:huzzah, :current]
       end
 
       it "should index :current when the code was pre-required" do
         subject.instance_variable_get("@faces")[:huzzah].should_not be_key :current
         require 'puppet/face/huzzah'
-        subject.face?(:huzzah, :current).should be_true
+        subject[:huzzah, :current].should be_true
       end
     end
 
     it "should not cause an invalid face to be enumerated later" do
-      subject.face?(:there_is_no_face, :current).should be_false
+      subject[:there_is_no_face, :current].should be_false
       subject.faces.should_not include :there_is_no_face
     end
   end
 
   describe "::register" do
     it "should store the face by name" do
       face = Puppet::Face.new(:my_face, '0.0.1')
       subject.register(face)
       subject.instance_variable_get("@faces").should == {:my_face => {'0.0.1' => face}}
     end
   end
 
   describe "::underscorize" do
     faulty = [1, "#foo", "$bar", "sturm und drang", :"sturm und drang"]
     valid  = {
       "Foo"      => :foo,
       :Foo       => :foo,
       "foo_bar"  => :foo_bar,
       :foo_bar   => :foo_bar,
       "foo-bar"  => :foo_bar,
       :"foo-bar" => :foo_bar,
     }
 
     valid.each do |input, expect|
       it "should map #{input.inspect} to #{expect.inspect}" do
         result = subject.underscorize(input)
         result.should == expect
       end
     end
 
     faulty.each do |input|
       it "should fail when presented with #{input.inspect} (#{input.class})" do
         expect { subject.underscorize(input) }.
           should raise_error ArgumentError, /not a valid face name/
       end
     end
   end
 end
diff --git a/spec/unit/interface_spec.rb b/spec/unit/interface_spec.rb
index b4fef0307..a1d70cf64 100755
--- a/spec/unit/interface_spec.rb
+++ b/spec/unit/interface_spec.rb
@@ -1,197 +1,220 @@
 require 'spec_helper'
 require 'puppet/face'
 require 'puppet/interface'
 
 describe Puppet::Interface do
   subject { Puppet::Interface }
 
-  before :all do
-    @faces = Puppet::Interface::FaceCollection.instance_variable_get("@faces").dup
-  end
-
   before :each do
+    @faces = Puppet::Interface::FaceCollection.
+      instance_variable_get("@faces").dup
+    @dq = $".dup
+    $".delete_if do |path| path =~ %r{/face/.*\.rb$} end
     Puppet::Interface::FaceCollection.instance_variable_get("@faces").clear
   end
 
-  after :all do
+  after :each do
     Puppet::Interface::FaceCollection.instance_variable_set("@faces", @faces)
+    $".clear ; @dq.each do |item| $" << item end
   end
 
   describe "#[]" do
     it "should fail when no version is requested" do
       expect { subject[:huzzah] }.should raise_error ArgumentError
     end
 
     it "should raise an exception when the requested version is unavailable" do
       expect { subject[:huzzah, '17.0.0'] }.should raise_error, Puppet::Error
     end
 
     it "should raise an exception when the requested face doesn't exist" do
       expect { subject[:burrble_toot, :current] }.should raise_error, Puppet::Error
     end
+
+    describe "version matching" do
+      { '1'     => '1.1.1',
+        '1.0'   => '1.0.1',
+        '1.0.1' => '1.0.1',
+        '1.1'   => '1.1.1',
+        '1.1.1' => '1.1.1'
+      }.each do |input, expect|
+        it "should match #{input.inspect} to #{expect.inspect}" do
+          face = subject[:version_matching, input]
+          face.should be
+          face.version.should == expect
+        end
+      end
+
+      %w{1.0.2 1.2}.each do |input|
+        it "should not match #{input.inspect} to any version" do
+          expect { subject[:version_matching, input] }.
+            to raise_error Puppet::Error, /Could not find version/
+        end
+      end
+    end
   end
 
   describe "#define" do
     it "should register the face" do
       face  = subject.define(:face_test_register, '0.0.1')
       face.should == subject[:face_test_register, '0.0.1']
     end
 
     it "should load actions" do
       subject.any_instance.expects(:load_actions)
       subject.define(:face_test_load_actions, '0.0.1')
     end
 
     it "should require a version number" do
       expect { subject.define(:no_version) }.to raise_error ArgumentError
     end
 
     it "should support summary builder and accessor methods" do
       subject.new(:foo, '1.0.0').should respond_to(:summary).with(0).arguments
       subject.new(:foo, '1.0.0').should respond_to(:summary=).with(1).arguments
     end
 
     # Required documentation methods...
     { :summary     => "summary",
       :description => "This is the description of the stuff\n\nWhee"
     }.each do |attr, value|
       it "should support #{attr} in the builder" do
         face = subject.new(:builder, '1.0.0') do
           self.send(attr, value)
         end
         face.send(attr).should == value
       end
     end
   end
 
   describe "#initialize" do
     it "should require a version number" do
       expect { subject.new(:no_version) }.to raise_error ArgumentError
     end
 
     it "should require a valid version number" do
       expect { subject.new(:bad_version, 'Rasins') }.
         should raise_error ArgumentError
     end
 
     it "should instance-eval any provided block" do
       face = subject.new(:face_test_block, '0.0.1') do
         action(:something) do
           when_invoked { "foo" }
         end
       end
 
       face.something.should == "foo"
     end
   end
 
   it "should have a name" do
     subject.new(:me, '0.0.1').name.should == :me
   end
 
   it "should stringify with its own name" do
     subject.new(:me, '0.0.1').to_s.should =~ /\bme\b/
   end
 
   # Why?
   it "should create a class-level autoloader" do
     subject.autoloader.should be_instance_of(Puppet::Util::Autoload)
   end
 
   it "should try to require faces that are not known" do
     pending "mocking require causes random stack overflow"
     subject::FaceCollection.expects(:require).with "puppet/face/foo"
     subject[:foo, '0.0.1']
   end
 
   it "should be able to load all actions in all search paths"
 
 
   it_should_behave_like "things that declare options" do
     def add_options_to(&block)
       subject.new(:with_options, '0.0.1', &block)
     end
   end
 
   describe "with face-level options" do
     it "should not return any action-level options" do
       face = subject.new(:with_options, '0.0.1') do
         option "--foo"
         option "--bar"
         action :baz do
           option "--quux"
         end
       end
       face.options.should =~ [:foo, :bar]
     end
 
     it "should fail when a face option duplicates an action option" do
       expect {
         subject.new(:action_level_options, '0.0.1') do
           action :bar do option "--foo" end
           option "--foo"
         end
       }.should raise_error ArgumentError, /Option foo conflicts with existing option foo on/i
     end
 
     it "should work when two actions have the same option" do
       face = subject.new(:with_options, '0.0.1') do
         action :foo do option "--quux" end
         action :bar do option "--quux" end
       end
 
       face.get_action(:foo).options.should =~ [:quux]
       face.get_action(:bar).options.should =~ [:quux]
     end
   end
 
   describe "with inherited options" do
     let :parent do
       parent = Class.new(subject)
       parent.option("--inherited")
       parent.action(:parent_action) do end
       parent
     end
 
     let :face do
       face = parent.new(:example, '0.2.1')
       face.option("--local")
       face.action(:face_action) do end
       face
     end
 
     describe "#options" do
       it "should list inherited options" do
         face.options.should =~ [:inherited, :local]
       end
 
       it "should see all options on face actions" do
         face.get_action(:face_action).options.should =~ [:inherited, :local]
       end
 
       it "should see all options on inherited actions accessed on the subclass" do
         face.get_action(:parent_action).options.should =~ [:inherited, :local]
       end
 
       it "should not see subclass actions on the parent class" do
         parent.options.should =~ [:inherited]
       end
 
       it "should not see subclass actions on actions accessed on the parent class" do
         parent.get_action(:parent_action).options.should =~ [:inherited]
       end
     end
 
     describe "#get_option" do
       it "should return an inherited option object" do
         face.get_option(:inherited).should be_an_instance_of subject::Option
       end
     end
   end
 
   it_should_behave_like "documentation on faces" do
     subject do
       Puppet::Interface.new(:face_documentation, '0.0.1')
     end
   end
 end