diff --git a/lib/puppet/parser/functions/fqdn_rand.rb b/lib/puppet/parser/functions/fqdn_rand.rb
index 52946f2c1..91157a148 100644
--- a/lib/puppet/parser/functions/fqdn_rand.rb
+++ b/lib/puppet/parser/functions/fqdn_rand.rb
@@ -1,12 +1,12 @@
 Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc =>
   "Generates random numbers based on the node's fqdn. Generated random values
   will be a range from 0 up to and excluding n, where n is the first parameter.
   The second argument specifies a number to add to the seed and is optional, for example:
 
       $random_number = fqdn_rand(30)
       $random_number_seed = fqdn_rand(30,30)") do |args|
-    require 'md5'
+    require 'digest/md5'
     max = args.shift
-    srand MD5.new([lookupvar('fqdn'),args].join(':')).to_s.hex
+    srand(Digest::MD5.hexdigest([lookupvar('fqdn'),args].join(':')).hex)
     rand(max).to_s
 end
diff --git a/lib/puppet/simple_graph.rb b/lib/puppet/simple_graph.rb
index ed71a64f3..27e068e30 100644
--- a/lib/puppet/simple_graph.rb
+++ b/lib/puppet/simple_graph.rb
@@ -1,591 +1,594 @@
 require 'puppet/external/dot'
 require 'puppet/relationship'
 require 'set'
 
 # A hopefully-faster graph class to replace the use of GRATR.
 class Puppet::SimpleGraph
   #
   # All public methods of this class must maintain (assume ^ ensure) the following invariants, where "=~=" means
   # equiv. up to order:
   #
   #   @in_to.keys =~= @out_to.keys =~= all vertices
   #   @in_to.values.collect { |x| x.values }.flatten =~= @out_from.values.collect { |x| x.values }.flatten =~= all edges
   #   @in_to[v1][v2] =~= @out_from[v2][v1] =~= all edges from v1 to v2
   #   @in_to   [v].keys =~= vertices with edges leading to   v
   #   @out_from[v].keys =~= vertices with edges leading from v
   #   no operation may shed reference loops (for gc)
   #   recursive operation must scale with the depth of the spanning trees, or better (e.g. no recursion over the set
   #       of all vertices, etc.)
   #
   # This class is intended to be used with DAGs.  However, if the
   # graph has a cycle, it will not cause non-termination of any of the
   # algorithms.  The topsort method detects and reports cycles.
   #
   def initialize
     @in_to = {}
     @out_from = {}
     @upstream_from = {}
     @downstream_from = {}
   end
 
   # Clear our graph.
   def clear
     @in_to.clear
     @out_from.clear
     @upstream_from.clear
     @downstream_from.clear
   end
 
   # Which resources depend upon the given resource.
   def dependencies(resource)
     vertex?(resource) ? upstream_from_vertex(resource).keys : []
   end
 
   def dependents(resource)
     vertex?(resource) ? downstream_from_vertex(resource).keys : []
   end
 
   # Whether our graph is directed.  Always true.  Used to produce dot files.
   def directed?
     true
   end
 
   # Determine all of the leaf nodes below a given vertex.
   def leaves(vertex, direction = :out)
     tree_from_vertex(vertex, direction).keys.find_all { |c| adjacent(c, :direction => direction).empty? }
   end
 
   # Collect all of the edges that the passed events match.  Returns
   # an array of edges.
   def matching_edges(event, base = nil)
     source = base || event.resource
 
     unless vertex?(source)
       Puppet.warning "Got an event from invalid vertex #{source.ref}"
       return []
     end
     # Get all of the edges that this vertex should forward events
     # to, which is the same thing as saying all edges directly below
     # This vertex in the graph.
     @out_from[source].values.flatten.find_all { |edge| edge.match?(event.name) }
   end
 
   # Return a reversed version of this graph.
   def reversal
     result = self.class.new
     vertices.each { |vertex| result.add_vertex(vertex) }
     edges.each do |edge|
       result.add_edge edge.class.new(edge.target, edge.source, edge.label)
     end
     result
   end
 
   # Return the size of the graph.
   def size
     vertices.size
   end
 
   def to_a
     vertices
   end
 
   # This is a simple implementation of Tarjan's algorithm to find strongly
   # connected components in the graph; this is a fairly ugly implementation,
   # because I can't just decorate the vertices themselves.
   #
   # This method has an unhealthy relationship with the find_cycles_in_graph
   # method below, which contains the knowledge of how the state object is
   # maintained.
   def tarjan(root, s)
     # initialize the recursion stack we use to work around the nasty lack of a
     # decent Ruby stack.
     recur = [{ :node => root }]
 
     while not recur.empty? do
       frame = recur.last
       vertex = frame[:node]
 
       case frame[:step]
       when nil then
         s[:index][vertex]   = s[:number]
         s[:lowlink][vertex] = s[:number]
         s[:number]          = s[:number] + 1
 
         s[:stack].push(vertex)
         s[:seen][vertex] = true
 
         frame[:children] = adjacent(vertex)
         frame[:step]     = :children
 
       when :children then
         if frame[:children].length > 0 then
           child = frame[:children].shift
           if ! s[:index][child] then
             # Never seen, need to recurse.
             frame[:step] = :after_recursion
             frame[:child] = child
             recur.push({ :node => child })
           elsif s[:seen][child] then
             s[:lowlink][vertex] = [s[:lowlink][vertex], s[:index][child]].min
           end
         else
           if s[:lowlink][vertex] == s[:index][vertex] then
             this_scc = []
             begin
               top = s[:stack].pop
               s[:seen][top] = false
               this_scc << top
             end until top == vertex
             # NOTE: if we don't reverse we get the components in the opposite
             # order to what a human being would expect; reverse should be an
             # O(1) operation, without even copying, because we know the length
             # of the source, but I worry that an implementation will get this
             # wrong.  Still, the worst case is O(n) for n vertices as we can't
             # possibly put a vertex into two SCCs.
             #
             # Also, my feeling is that most implementations are going to do
             # better with a reverse operation than a string of 'unshift'
             # insertions at the head of the array; if they were going to mess
             # up the performance of one, it would be unshift.
             s[:scc] << this_scc.reverse
           end
           recur.pop               # done with this node, finally.
         end
 
       when :after_recursion then
         s[:lowlink][vertex] = [s[:lowlink][vertex], s[:lowlink][frame[:child]]].min
         frame[:step] = :children
 
       else
         fail "#{frame[:step]} is an unknown step"
       end
     end
   end
 
   # Find all cycles in the graph by detecting all the strongly connected
   # components, then eliminating everything with a size of one as
   # uninteresting - which it is, because it can't be a cycle. :)
   #
   # This has an unhealthy relationship with the 'tarjan' method above, which
   # it uses to implement the detection of strongly connected components.
   def find_cycles_in_graph
     state = {
       :number => 0, :index => {}, :lowlink => {}, :scc => [],
       :stack => [], :seen => {}
     }
 
     # we usually have a disconnected graph, must walk all possible roots
     vertices.each do |vertex|
       if ! state[:index][vertex] then
         tarjan vertex, state
       end
     end
 
     state[:scc].select { |c| c.length > 1 }
   end
 
   # Perform a BFS on the sub graph representing the cycle, with a view to
   # generating a sufficient set of paths to report the cycle meaningfully, and
   # ideally usefully, for the end user.
   #
   # BFS is preferred because it will generally report the shortest paths
   # through the graph first, which are more likely to be interesting to the
   # user.  I think; it would be interesting to verify that. --daniel 2011-01-23
   def paths_in_cycle(cycle, max_paths = 1)
     raise ArgumentError, "negative or zero max_paths" if max_paths < 1
 
     # Calculate our filtered outbound vertex lists...
     adj = {}
     cycle.each do |vertex|
       adj[vertex] = adjacent(vertex).select{|s| cycle.member? s}
     end
 
     found = []
 
     # frame struct is vertex, [path]
     stack = [[cycle.first, []]]
     while frame = stack.shift do
       if frame[1].member?(frame[0]) then
         found << frame[1] + [frame[0]]
         break if found.length >= max_paths
       else
         adj[frame[0]].each do |to|
           stack.push [to, frame[1] + [frame[0]]]
         end
       end
     end
 
     return found
   end
 
   def report_cycles_in_graph
     cycles = find_cycles_in_graph
     n = cycles.length           # where is "pluralize"? --daniel 2011-01-22
     s = n == 1 ? '' : 's'
 
     message = "Found #{n} dependency cycle#{s}:\n"
     cycles.each do |cycle|
       paths = paths_in_cycle(cycle)
       message += paths.map{ |path| '(' + path.join(" => ") + ')'}.join("\n") + "\n"
     end
 
     if Puppet[:graph] then
       filename = write_cycles_to_graph(cycles)
       message += "Cycle graph written to #{filename}."
     else
       message += "Try the '--graph' option and opening the "
       message += "resulting '.dot' file in OmniGraffle or GraphViz"
     end
 
     raise Puppet::Error, message
   end
 
   def write_cycles_to_graph(cycles)
     # This does not use the DOT graph library, just writes the content
     # directly.  Given the complexity of this, there didn't seem much point
     # using a heavy library to generate exactly the same content. --daniel 2011-01-27
     Puppet.settings.use(:graphing)
 
     graph = ["digraph Resource_Cycles {"]
     graph << '  label = "Resource Cycles"'
 
     cycles.each do |cycle|
       paths_in_cycle(cycle, 10).each do |path|
         graph << path.map { |v| '"' + v.to_s.gsub(/"/, '\\"') + '"' }.join(" -> ")
       end
     end
 
     graph << '}'
 
     filename = File.join(Puppet[:graphdir], "cycles.dot")
     File.open(filename, "w") { |f| f.puts graph }
     return filename
   end
 
   # Provide a topological sort.
   def topsort
     degree = {}
     zeros = []
     result = []
 
     # Collect each of our vertices, with the number of in-edges each has.
     vertices.each do |v|
       edges = @in_to[v]
       zeros << v if edges.empty?
       degree[v] = edges.length
     end
 
     # Iterate over each 0-degree vertex, decrementing the degree of
     # each of its out-edges.
     while v = zeros.pop
       result << v
       @out_from[v].each { |v2,es|
         zeros << v2 if (degree[v2] -= 1) == 0
       }
     end
 
     # If we have any vertices left with non-zero in-degrees, then we've found a cycle.
     if cycles = degree.values.reject { |ns| ns == 0  } and cycles.length > 0
       report_cycles_in_graph
     end
 
     result
   end
 
   # Add a new vertex to the graph.
   def add_vertex(vertex)
     @in_to[vertex]    ||= {}
     @out_from[vertex] ||= {}
   end
 
   # Remove a vertex from the graph.
   def remove_vertex!(v)
     return unless vertex?(v)
     @upstream_from.clear
     @downstream_from.clear
     (@in_to[v].values+@out_from[v].values).flatten.each { |e| remove_edge!(e) }
     @in_to.delete(v)
     @out_from.delete(v)
   end
 
   # Test whether a given vertex is in the graph.
   def vertex?(v)
     @in_to.include?(v)
   end
 
   # Return a list of all vertices.
   def vertices
     @in_to.keys
   end
 
   # Add a new edge.  The graph user has to create the edge instance,
   # since they have to specify what kind of edge it is.
   def add_edge(e,*a)
     return add_relationship(e,*a) unless a.empty?
     @upstream_from.clear
     @downstream_from.clear
     add_vertex(e.source)
     add_vertex(e.target)
     @in_to[   e.target][e.source] ||= []; @in_to[   e.target][e.source] |= [e]
     @out_from[e.source][e.target] ||= []; @out_from[e.source][e.target] |= [e]
   end
 
   def add_relationship(source, target, label = nil)
     add_edge Puppet::Relationship.new(source, target, label)
   end
 
   # Find all matching edges.
   def edges_between(source, target)
     (@out_from[source] || {})[target] || []
   end
 
   # Is there an edge between the two vertices?
   def edge?(source, target)
     vertex?(source) and vertex?(target) and @out_from[source][target]
   end
 
   def edges
     @in_to.values.collect { |x| x.values }.flatten
   end
 
   def each_edge
     @in_to.each { |t,ns| ns.each { |s,es| es.each { |e| yield e }}}
   end
 
   # Remove an edge from our graph.
   def remove_edge!(e)
     if edge?(e.source,e.target)
       @upstream_from.clear
       @downstream_from.clear
       @in_to   [e.target].delete e.source if (@in_to   [e.target][e.source] -= [e]).empty?
       @out_from[e.source].delete e.target if (@out_from[e.source][e.target] -= [e]).empty?
     end
   end
 
   # Find adjacent edges.
   def adjacent(v, options = {})
     return [] unless ns = (options[:direction] == :in) ? @in_to[v] : @out_from[v]
     (options[:type] == :edges) ? ns.values.flatten : ns.keys
   end
 
   # Take container information from another graph and use it
   # to replace any container vertices with their respective leaves.
   # This creates direct relationships where there were previously
   # indirect relationships through the containers.
   def splice!(other, type)
     # We have to get the container list via a topological sort on the
     # configuration graph, because otherwise containers that contain
     # other containers will add those containers back into the
     # graph.  We could get a similar affect by only setting relationships
     # to container leaves, but that would result in many more
     # relationships.
     stage_class = Puppet::Type.type(:stage)
     whit_class  = Puppet::Type.type(:whit)
     containers = other.topsort.find_all { |v| (v.is_a?(type) or v.is_a?(stage_class)) and vertex?(v) }
     containers.each do |container|
       # Get the list of children from the other graph.
       children = other.adjacent(container, :direction => :out)
 
       # MQR TODO: Luke suggests that it should be possible to refactor the system so that
       #           container nodes are retained, thus obviating the need for the whit.
       children = [whit_class.new(:name => container.name, :catalog => other)] if children.empty?
 
       # First create new edges for each of the :in edges
       [:in, :out].each do |dir|
         edges = adjacent(container, :direction => dir, :type => :edges)
         edges.each do |edge|
           children.each do |child|
             if dir == :in
               s = edge.source
               t = child
             else
               s = child
               t = edge.target
             end
 
             add_edge(s, t, edge.label)
           end
 
           # Now get rid of the edge, so remove_vertex! works correctly.
           remove_edge!(edge)
         end
       end
       remove_vertex!(container)
     end
   end
 
   # Just walk the tree and pass each edge.
   def walk(source, direction)
     # Use an iterative, breadth-first traversal of the graph. One could do
     # this recursively, but Ruby's slow function calls and even slower
     # recursion make the shorter, recursive algorithm cost-prohibitive.
     stack = [source]
     seen = Set.new
     until stack.empty?
       node = stack.shift
       next if seen.member? node
       connected = adjacent(node, :direction => direction)
       connected.each do |target|
         yield node, target
       end
       stack.concat(connected)
       seen << node
     end
   end
 
   # A different way of walking a tree, and a much faster way than the
   # one that comes with GRATR.
   def tree_from_vertex(start, direction = :out)
     predecessor={}
     walk(start, direction) do |parent, child|
       predecessor[child] = parent
     end
     predecessor
   end
 
   def downstream_from_vertex(v)
     return @downstream_from[v] if @downstream_from[v]
     result = @downstream_from[v] = {}
     @out_from[v].keys.each do |node|
       result[node] = 1
       result.update(downstream_from_vertex(node))
     end
     result
   end
 
   def upstream_from_vertex(v)
     return @upstream_from[v] if @upstream_from[v]
     result = @upstream_from[v] = {}
     @in_to[v].keys.each do |node|
       result[node] = 1
       result.update(upstream_from_vertex(node))
     end
     result
   end
 
   # LAK:FIXME This is just a paste of the GRATR code with slight modifications.
 
   # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
   # undirected Graph.  _params_ can contain any graph property specified in
   # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
   # which match +dot+ properties will be used as well.
   def to_dot_graph (params = {})
     params['name'] ||= self.class.name.gsub(/:/,'_')
     fontsize   = params['fontsize'] ? params['fontsize'] : '8'
     graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
     edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
     vertices.each do |v|
       name = v.to_s
       params = {'name'     => '"'+name+'"',
         'fontsize' => fontsize,
         'label'    => name}
       v_label = v.to_s
       params.merge!(v_label) if v_label and v_label.kind_of? Hash
       graph << DOT::DOTNode.new(params)
     end
     edges.each do |e|
       params = {'from'     => '"'+ e.source.to_s + '"',
         'to'       => '"'+ e.target.to_s + '"',
         'fontsize' => fontsize }
       e_label = e.to_s
       params.merge!(e_label) if e_label and e_label.kind_of? Hash
       graph << edge_klass.new(params)
     end
     graph
   end
 
   # Output the dot format as a string
   def to_dot (params={}) to_dot_graph(params).to_s; end
 
   # Call +dotty+ for the graph which is written to the file 'graph.dot'
   # in the # current directory.
   def dotty (params = {}, dotfile = 'graph.dot')
     File.open(dotfile, 'w') {|f| f << to_dot(params) }
     system('dotty', dotfile)
   end
 
   # Produce the graph files if requested.
   def write_graph(name)
     return unless Puppet[:graph]
 
     Puppet.settings.use(:graphing)
 
     file = File.join(Puppet[:graphdir], "#{name}.dot")
     File.open(file, "w") { |f|
       f.puts to_dot("name" => name.to_s.capitalize)
     }
   end
 
   # This flag may be set to true to use the new YAML serialzation
   # format (where @vertices is a simple list of vertices rather than a
   # list of VertexWrapper objects).  Deserialization supports both
   # formats regardless of the setting of this flag.
   class << self
     attr_accessor :use_new_yaml_format
   end
   self.use_new_yaml_format = false
 
   # Stub class to allow graphs to be represented in YAML using the old
   # (version 2.6) format.
   class VertexWrapper
     attr_reader :vertex, :adjacencies
     def initialize(vertex, adjacencies)
       @vertex = vertex
       @adjacencies = adjacencies
     end
 
     def inspect
       { :@adjacencies => @adjacencies, :@vertex => @vertex.to_s }.inspect
     end
   end
 
   # instance_variable_get is used by Object.to_zaml to get instance
   # variables.  Override it so that we can simulate the presence of
   # instance variables @edges and @vertices for serialization.
   def instance_variable_get(v)
     case v.to_s
     when '@edges' then
       edges
     when '@vertices' then
       if self.class.use_new_yaml_format
         vertices
       else
         result = {}
         vertices.each do |vertex|
           adjacencies = {}
           [:in, :out].each do |direction|
             adjacencies[direction] = {}
             adjacent(vertex, :direction => direction, :type => :edges).each do |edge|
               other_vertex = direction == :in ? edge.source : edge.target
               (adjacencies[direction][other_vertex] ||= Set.new).add(edge)
             end
           end
           result[vertex] = Puppet::SimpleGraph::VertexWrapper.new(vertex, adjacencies)
         end
         result
       end
     else
       super(v)
     end
   end
 
   def to_yaml_properties
-    other_vars = instance_variables.reject { |v| %w{@in_to @out_from @upstream_from @downstream_from}.include?(v) }
+    other_vars = instance_variables.
+      map {|v| v.to_s}.
+      reject { |v| %w{@in_to @out_from @upstream_from @downstream_from}.include?(v) }
+
     (other_vars + %w{@vertices @edges}).sort.uniq
   end
 
   def yaml_initialize(tag, var)
     initialize()
     vertices = var.delete('vertices')
     edges = var.delete('edges')
     if vertices.is_a?(Hash)
       # Support old (2.6) format
       vertices = vertices.keys
     end
     vertices.each { |v| add_vertex(v) }
     edges.each { |e| add_edge(e) }
     var.each do |varname, value|
       instance_variable_set("@#{varname}", value)
     end
   end
 end
diff --git a/lib/puppet/transaction/event.rb b/lib/puppet/transaction/event.rb
index cd695cff8..d3f25b71c 100644
--- a/lib/puppet/transaction/event.rb
+++ b/lib/puppet/transaction/event.rb
@@ -1,66 +1,66 @@
 require 'puppet/transaction'
 require 'puppet/util/tagging'
 require 'puppet/util/logging'
 
 # A simple struct for storing what happens on the system.
 class Puppet::Transaction::Event
   include Puppet::Util::Tagging
   include Puppet::Util::Logging
 
   ATTRIBUTES = [:name, :resource, :property, :previous_value, :desired_value, :historical_value, :status, :message, :file, :line, :source_description, :audited]
   YAML_ATTRIBUTES = %w{@audited @property @previous_value @desired_value @historical_value @message @name @status @time}
   attr_accessor *ATTRIBUTES
   attr_writer :tags
   attr_accessor :time
   attr_reader :default_log_level
 
   EVENT_STATUSES = %w{noop success failure audit}
 
   def initialize(options = {})
     @audited = false
     options.each { |attr, value| send(attr.to_s + "=", value) }
 
     @time = Time.now
   end
 
   def property=(prop)
     @property = prop.to_s
   end
 
   def resource=(res)
     if res.respond_to?(:[]) and level = res[:loglevel]
       @default_log_level = level
     end
     @resource = res.to_s
   end
 
   def send_log
     super(log_level, message)
   end
 
   def status=(value)
     raise ArgumentError, "Event status can only be #{EVENT_STATUSES.join(', ')}" unless EVENT_STATUSES.include?(value)
     @status = value
   end
 
   def to_s
     message
   end
 
   def to_yaml_properties
-    (YAML_ATTRIBUTES & instance_variables).sort
+    (YAML_ATTRIBUTES.map {|ya| ya.to_s} & instance_variables.map{|iv| iv.to_s}).sort
   end
 
   private
 
   # If it's a failure, use 'err', else use either the resource's log level (if available)
   # or 'notice'.
   def log_level
     status == "failure" ? :err : (@default_log_level || :notice)
   end
 
   # Used by the Logging module
   def log_source
     source_description || property || resource
   end
 end
diff --git a/lib/puppet/type/tidy.rb b/lib/puppet/type/tidy.rb
index 93a7e96cf..146481fed 100755
--- a/lib/puppet/type/tidy.rb
+++ b/lib/puppet/type/tidy.rb
@@ -1,333 +1,333 @@
 Puppet::Type.newtype(:tidy) do
   require 'puppet/file_serving/fileset'
   require 'puppet/file_bucket/dipper'
 
   @doc = "Remove unwanted files based on specific criteria.  Multiple
     criteria are OR'd together, so a file that is too large but is not
     old enough will still get tidied.
 
     If you don't specify either `age` or `size`, then all files will
     be removed.
 
     This resource type works by generating a file resource for every file
     that should be deleted and then letting that resource perform the
     actual deletion.
     "
 
   newparam(:path) do
     desc "The path to the file or directory to manage.  Must be fully
       qualified."
     isnamevar
   end
 
   newparam(:recurse) do
     desc "If target is a directory, recursively descend
       into the directory looking for files to tidy."
 
     newvalues(:true, :false, :inf, /^[0-9]+$/)
 
     # Replace the validation so that we allow numbers in
     # addition to string representations of them.
     validate { |arg| }
     munge do |value|
       newval = super(value)
       case newval
       when :true, :inf; true
       when :false; false
       when Integer, Fixnum, Bignum; value
       when /^\d+$/; Integer(value)
       else
         raise ArgumentError, "Invalid recurse value #{value.inspect}"
       end
     end
   end
 
   newparam(:matches) do
     desc "One or more (shell type) file glob patterns, which restrict
       the list of files to be tidied to those whose basenames match
       at least one of the patterns specified. Multiple patterns can
       be specified using an array.
 
       Example:
 
           tidy { \"/tmp\":
             age => \"1w\",
             recurse => 1,
             matches => [ \"[0-9]pub*.tmp\", \"*.temp\", \"tmpfile?\" ]
           }
 
       This removes files from `/tmp` if they are one week old or older,
       are not in a subdirectory and match one of the shell globs given.
 
       Note that the patterns are matched against the basename of each
       file -- that is, your glob patterns should not have any '/'
       characters in them, since you are only specifying against the last
       bit of the file.
 
       Finally, note that you must now specify a non-zero/non-false value
       for recurse if matches is used, as matches only apply to files found
       by recursion (there's no reason to use static patterns match against
       a statically determined path).  Requiering explicit recursion clears
       up a common source of confusion."
 
     # Make sure we convert to an array.
     munge do |value|
       fail "Tidy can't use matches with recurse 0, false, or undef" if "#{@resource[:recurse]}" =~ /^(0|false|)$/
       [value].flatten
     end
 
     # Does a given path match our glob patterns, if any?  Return true
     # if no patterns have been provided.
     def tidy?(path, stat)
       basename = File.basename(path)
       flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
       return(value.find {|pattern| File.fnmatch(pattern, basename, flags) } ? true : false)
     end
   end
 
   newparam(:backup) do
     desc "Whether tidied files should be backed up.  Any values are passed
       directly to the file resources used for actual file deletion, so use
       its backup documentation to determine valid values."
   end
 
   newparam(:age) do
     desc "Tidy files whose age is equal to or greater than
       the specified time.  You can choose seconds, minutes,
       hours, days, or weeks by specifying the first letter of any
       of those words (e.g., '1w').
 
       Specifying 0 will remove all files."
 
     @@ageconvertors = {
       :s => 1,
       :m => 60
     }
 
     @@ageconvertors[:h] = @@ageconvertors[:m] * 60
     @@ageconvertors[:d] = @@ageconvertors[:h] * 24
     @@ageconvertors[:w] = @@ageconvertors[:d] * 7
 
     def convert(unit, multi)
       if num = @@ageconvertors[unit]
         return num * multi
       else
         self.fail "Invalid age unit '#{unit}'"
       end
     end
 
     def tidy?(path, stat)
       # If the file's older than we allow, we should get rid of it.
       (Time.now.to_i - stat.send(resource[:type]).to_i) > value
     end
 
     munge do |age|
       unit = multi = nil
       case age
       when /^([0-9]+)(\w)\w*$/
         multi = Integer($1)
         unit = $2.downcase.intern
       when /^([0-9]+)$/
         multi = Integer($1)
         unit = :d
       else
         self.fail "Invalid tidy age #{age}"
       end
 
       convert(unit, multi)
     end
   end
 
   newparam(:size) do
     desc "Tidy files whose size is equal to or greater than
       the specified size.  Unqualified values are in kilobytes, but
       *b*, *k*, *m*, *g*, and *t* can be appended to specify *bytes*,
       *kilobytes*, *megabytes*, *gigabytes*, and *terabytes*, respectively.
       Only the first character is significant, so the full word can also 
       be used."
 
     @@sizeconvertors = {
       :b => 0,
       :k => 1,
       :m => 2,
       :g => 3,
       :t => 4
     }
 
     def convert(unit, multi)
       if num = @@sizeconvertors[unit]
         result = multi
         num.times do result *= 1024 end
         return result
       else
         self.fail "Invalid size unit '#{unit}'"
       end
     end
 
     def tidy?(path, stat)
       stat.size >= value
     end
 
     munge do |size|
       case size
       when /^([0-9]+)(\w)\w*$/
         multi = Integer($1)
         unit = $2.downcase.intern
       when /^([0-9]+)$/
         multi = Integer($1)
         unit = :k
       else
         self.fail "Invalid tidy size #{age}"
       end
 
       convert(unit, multi)
     end
   end
 
   newparam(:type) do
     desc "Set the mechanism for determining age."
 
     newvalues(:atime, :mtime, :ctime)
 
     defaultto :atime
   end
 
   newparam(:rmdirs, :boolean => true) do
     desc "Tidy directories in addition to files; that is, remove
       directories whose age is older than the specified criteria.
       This will only remove empty directories, so all contained
       files must also be tidied before a directory gets removed."
 
     newvalues :true, :false
   end
 
   # Erase PFile's validate method
   validate do
   end
 
   def self.instances
     []
   end
 
   @depthfirst = true
 
   def initialize(hash)
     super
 
     # only allow backing up into filebuckets
     self[:backup] = false unless self[:backup].is_a? Puppet::FileBucket::Dipper
   end
 
   # Make a file resource to remove a given file.
   def mkfile(path)
     # Force deletion, so directories actually get deleted.
     Puppet::Type.type(:file).new :path => path, :backup => self[:backup], :ensure => :absent, :force => true
   end
 
   def retrieve
     # Our ensure property knows how to retrieve everything for us.
     if obj = @parameters[:ensure]
       return obj.retrieve
     else
       return {}
     end
   end
 
   # Hack things a bit so we only ever check the ensure property.
   def properties
     []
   end
 
   def eval_generate
     []
   end
 
   def generate
     return [] unless stat(self[:path])
 
     case self[:recurse]
     when Integer, Fixnum, Bignum, /^\d+$/
       parameter = { :recurse => true, :recurselimit => self[:recurse] }
     when true, :true, :inf
       parameter = { :recurse => true }
     end
 
     if parameter
       files = Puppet::FileServing::Fileset.new(self[:path], parameter).files.collect do |f|
-        f == "." ? self[:path] : File.join(self[:path], f)
+        f == "." ? self[:path] : ::File.join(self[:path], f)
       end
     else
       files = [self[:path]]
     end
     result = files.find_all { |path| tidy?(path) }.collect { |path| mkfile(path) }.each { |file| notice "Tidying #{file.ref}" }.sort { |a,b| b[:path] <=> a[:path] }
 
     # No need to worry about relationships if we don't have rmdirs; there won't be
     # any directories.
     return result unless rmdirs?
 
     # Now make sure that all directories require the files they contain, if all are available,
     # so that a directory is emptied before we try to remove it.
     files_by_name = result.inject({}) { |hash, file| hash[file[:path]] = file; hash }
 
     files_by_name.keys.sort { |a,b| b <=> b }.each do |path|
-      dir = File.dirname(path)
+      dir = ::File.dirname(path)
       next unless resource = files_by_name[dir]
       if resource[:require]
         resource[:require] << Puppet::Resource.new(:file, path)
       else
         resource[:require] = [Puppet::Resource.new(:file, path)]
       end
     end
 
     result
   end
 
   # Does a given path match our glob patterns, if any?  Return true
   # if no patterns have been provided.
   def matches?(path)
     return true unless self[:matches]
 
     basename = File.basename(path)
     flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
     if self[:matches].find {|pattern| File.fnmatch(pattern, basename, flags) }
       return true
     else
       debug "No specified patterns match #{path}, not tidying"
       return false
     end
   end
 
   # Should we remove the specified file?
   def tidy?(path)
     return false unless stat = self.stat(path)
 
     return false if stat.ftype == "directory" and ! rmdirs?
 
     # The 'matches' parameter isn't OR'ed with the other tests --
     # it's just used to reduce the list of files we can match.
     return false if param = parameter(:matches) and ! param.tidy?(path, stat)
 
     tested = false
     [:age, :size].each do |name|
       next unless param = parameter(name)
       tested = true
       return true if param.tidy?(path, stat)
     end
 
     # If they don't specify either, then the file should always be removed.
     return true unless tested
     false
   end
 
   def stat(path)
     begin
-      File.lstat(path)
+      ::File.lstat(path)
     rescue Errno::ENOENT => error
       info "File does not exist"
       return nil
     rescue Errno::EACCES => error
       warning "Could not stat; permission denied"
       return nil
     end
   end
 end
diff --git a/lib/puppet/type/zone.rb b/lib/puppet/type/zone.rb
index 1bae93120..0fc702ccf 100644
--- a/lib/puppet/type/zone.rb
+++ b/lib/puppet/type/zone.rb
@@ -1,490 +1,490 @@
 Puppet::Type.newtype(:zone) do
   @doc = "Solaris zones.
 
 **Autorequires:** If Puppet is managing the directory specified as the root of the zone's filesystem (with the `path` attribute), the zone resource will autorequire that directory."
 
   # These properties modify the zone configuration, and they need to provide
   # the text separately from syncing it, so all config statements can be rolled
   # into a single creation statement.
   class ZoneConfigProperty < Puppet::Property
     # Perform the config operation.
     def sync
       provider.setconfig self.configtext
     end
   end
 
   # Those properties that can have multiple instances.
   class ZoneMultiConfigProperty < ZoneConfigProperty
     def configtext
       list = @should
 
       current_value = self.retrieve
 
       unless current_value.is_a? Symbol
         if current_value.is_a? Array
           list += current_value
         else
           list << current_value if current_value
         end
       end
 
       # Some hackery so we can test whether current_value is an array or a symbol
       if current_value.is_a? Array
         tmpis = current_value
       else
         if current_value
           tmpis = [current_value]
         else
           tmpis = []
         end
       end
 
       rms = []
       adds = []
 
       # Collect the modifications to make
       list.sort.uniq.collect do |obj|
         # Skip objectories that are configured and should be
         next if tmpis.include?(obj) and @should.include?(obj)
 
         if tmpis.include?(obj)
           rms << obj
         else
           adds << obj
         end
       end
 
 
       # And then perform all of the removals before any of the adds.
       (rms.collect { |o| rm(o) } + adds.collect { |o| add(o) }).join("\n")
     end
 
     # We want all specified directories to be included.
     def insync?(current_value)
       if current_value.is_a? Array and @should.is_a? Array
         current_value.sort == @should.sort
       else
         current_value == @should
       end
     end
   end
 
   ensurable do
     desc "The running state of the zone.  The valid states directly reflect
       the states that `zoneadm` provides.  The states are linear,
       in that a zone must be `configured` then `installed`, and
       only then can be `running`.  Note also that `halt` is currently
       used to stop zones."
 
     @states = {}
     @parametervalues = []
 
     def self.alias_state(values)
       @state_aliases ||= {}
       values.each do |nick, name|
         @state_aliases[nick] = name
       end
     end
 
     def self.newvalue(name, hash)
       @parametervalues = [] if @parametervalues.is_a? Hash
 
       @parametervalues << name
 
       @states[name] = hash
       hash[:name] = name
     end
 
     def self.state_name(name)
       if other = @state_aliases[name]
         other
       else
         name
       end
     end
 
     newvalue :absent, :down => :destroy
     newvalue :configured, :up => :configure, :down => :uninstall
     newvalue :installed, :up => :install, :down => :stop
     newvalue :running, :up => :start
 
     alias_state :incomplete => :installed, :ready => :installed, :shutting_down => :running
 
     defaultto :running
 
     def self.state_index(value)
       @parametervalues.index(state_name(value))
     end
 
     # Return all of the states between two listed values, exclusive
     # of the first item.
     def self.state_sequence(first, second)
       findex = sindex = nil
       unless findex = @parametervalues.index(state_name(first))
         raise ArgumentError, "'#{first}' is not a valid zone state"
       end
       unless sindex = @parametervalues.index(state_name(second))
         raise ArgumentError, "'#{first}' is not a valid zone state"
       end
       list = nil
 
       # Apparently ranges are unidirectional, so we have to reverse
       # the range op twice.
       if findex > sindex
         list = @parametervalues[sindex..findex].collect do |name|
           @states[name]
         end.reverse
       else
         list = @parametervalues[findex..sindex].collect do |name|
           @states[name]
         end
       end
 
       # The first result is the current state, so don't return it.
       list[1..-1]
     end
 
     def retrieve
       provider.properties[:ensure]
     end
 
     def sync
       method = nil
       if up?
         direction = :up
       else
         direction = :down
       end
 
       # We need to get the state we're currently in and just call
       # everything between it and us.
       self.class.state_sequence(self.retrieve, self.should).each do |state|
         if method = state[direction]
           warned = false
           while provider.processing?
             unless warned
               info "Waiting for zone to finish processing"
               warned = true
             end
             sleep 1
           end
           provider.send(method)
         else
           raise Puppet::DevError, "Cannot move #{direction} from #{st[:name]}"
         end
       end
 
       ("zone_#{self.should}").intern
     end
 
     # Are we moving up the property tree?
     def up?
       current_value = self.retrieve
       self.class.state_index(current_value) < self.class.state_index(self.should)
     end
   end
 
   newparam(:name) do
     desc "The name of the zone."
 
     isnamevar
   end
 
   newparam(:id) do
     desc "The numerical ID of the zone.  This number is autogenerated
       and cannot be changed."
   end
 
   newparam(:clone) do
     desc "Instead of installing the zone, clone it from another zone.
       If the zone root resides on a zfs file system, a snapshot will be
       used to create the clone, is it redisides on ufs, a copy of the zone
       will be used. The zone you clone from must not be running."
   end
 
   newproperty(:ip, :parent => ZoneMultiConfigProperty) do
     require 'ipaddr'
 
     desc "The IP address of the zone.  IP addresses must be specified
       with the interface, separated by a colon, e.g.: bge0:192.168.0.1.
       For multiple interfaces, specify them in an array."
 
     # Add an interface.
     def add(str)
       interface, ip, defrouter = ipsplit(str)
       cmd = "add net\n"
       cmd += "set physical=#{interface}\n" if interface
       cmd += "set address=#{ip}\n" if ip
       cmd += "set defrouter=#{defrouter}\n" if defrouter
       #if @resource[:iptype] == :shared
       cmd += "end\n"
     end
 
     # Convert a string into the component interface, address and defrouter
     def ipsplit(str)
       interface, address, defrouter = str.split(':')
       return interface, address, defrouter
     end
 
     # Remove an interface.
     def rm(str)
       interface, ip, defrouter = ipsplit(str)
       # Reality seems to disagree with the documentation here; the docs
       # specify that braces are required, but they're apparently only
       # required if you're specifying multiple values.
       if ip
         "remove net address=#{ip}"
       elsif interface
         "remove net interface=#{interface}"
       else
         raise ArgumentError, "can not remove network based on default router"
       end
     end
   end
 
   newproperty(:iptype, :parent => ZoneConfigProperty) do
     desc "The IP stack type of the zone. Can either be 'shared' or 'exclusive'."
 
     defaultto :shared
 
     newvalue :shared
     newvalue :exclusive
 
     def configtext
       "set ip-type=#{self.should}"
     end
   end
 
   newproperty(:autoboot, :parent => ZoneConfigProperty) do
     desc "Whether the zone should automatically boot."
 
     defaultto true
 
     newvalue(:true) {}
     newvalue(:false) {}
 
     def configtext
       "set autoboot=#{self.should}"
     end
   end
 
   newproperty(:pool, :parent => ZoneConfigProperty) do
     desc "The resource pool for this zone."
 
     def configtext
       "set pool=#{self.should}"
     end
   end
 
   newproperty(:shares, :parent => ZoneConfigProperty) do
     desc "Number of FSS CPU shares allocated to the zone."
 
     def configtext
       "add rctl\nset name=zone.cpu-shares\nadd value (priv=privileged,limit=#{self.should},action=none)\nend"
     end
   end
 
   newproperty(:dataset, :parent => ZoneMultiConfigProperty) do
     desc "The list of datasets delegated to the non global zone from the
       global zone.  All datasets must be zfs filesystem names which is
       different than the mountpoint." 
 
     validate do |value|
       unless value !~ /^\//
         raise ArgumentError, "Datasets must be the name of a zfs filesystem"
       end
     end
 
     # Add a zfs filesystem to our list of datasets.
     def add(dataset)
       "add dataset\nset name=#{dataset}\nend"
     end
 
     # Remove a zfs filesystem from our list of datasets.
     def rm(dataset)
       "remove dataset name=#{dataset}"
     end
 
     def should
       @should
     end
   end
 
 
   newproperty(:inherit, :parent => ZoneMultiConfigProperty) do
     desc "The list of directories that the zone inherits from the global
       zone.  All directories must be fully qualified."
 
     validate do |value|
       unless value =~ /^\//
         raise ArgumentError, "Inherited filesystems must be fully qualified"
       end
     end
 
     # Add a directory to our list of inherited directories.
     def add(dir)
       "add inherit-pkg-dir\nset dir=#{dir}\nend"
     end
 
     def rm(dir)
       # Reality seems to disagree with the documentation here; the docs
       # specify that braces are required, but they're apparently only
       # required if you're specifying multiple values.
       "remove inherit-pkg-dir dir=#{dir}"
     end
 
     def should
       @should
     end
   end
 
   # Specify the sysidcfg file.  This is pretty hackish, because it's
   # only used to boot the zone the very first time.
   newparam(:sysidcfg) do
     desc %{The text to go into the sysidcfg file when the zone is first
       booted.  The best way is to use a template:
 
           # $templatedir/sysidcfg
           system_locale=en_US
           timezone=GMT
           terminal=xterms
           security_policy=NONE
           root_password=<%= password %>
           timeserver=localhost
           name_service=DNS {domain_name=<%= domain %> name_server=<%= nameserver %>}
           network_interface=primary {hostname=<%= realhostname %>
             ip_address=<%= ip %>
             netmask=<%= netmask %>
             protocol_ipv6=no
             default_route=<%= defaultroute %>}
           nfs4_domain=dynamic
 
       And then call that:
 
           zone { myzone:
             ip => "bge0:192.168.0.23",
             sysidcfg => template(sysidcfg),
             path => "/opt/zones/myzone",
             realhostname => "fully.qualified.domain.name"
           }
 
       The sysidcfg only matters on the first booting of the zone,
       so Puppet only checks for it at that time.}
   end
 
   newparam(:path) do
     desc "The root of the zone's filesystem.  Must be a fully qualified
       file name.  If you include '%s' in the path, then it will be
       replaced with the zone's name.  At this point, you cannot use
       Puppet to move a zone."
 
     validate do |value|
       unless value =~ /^\//
         raise ArgumentError, "The zone base must be fully qualified"
       end
     end
 
     munge do |value|
       if value =~ /%s/
         value % @resource[:name]
       else
         value
       end
     end
   end
 
   newparam(:create_args) do
     desc "Arguments to the zonecfg create command.  This can be used to create branded zones."
   end
 
   newparam(:install_args) do
     desc "Arguments to the zoneadm install command.  This can be used to create branded zones."
   end
 
   newparam(:realhostname) do
     desc "The actual hostname of the zone."
   end
 
   # If Puppet is also managing the base dir or its parent dir, list them
   # both as prerequisites.
   autorequire(:file) do
     if @parameters.include? :path
-      [@parameters[:path].value, File.dirname(@parameters[:path].value)]
+      [@parameters[:path].value, ::File.dirname(@parameters[:path].value)]
     else
       nil
     end
   end
 
   # If Puppet is also managing the zfs filesystem which is the zone dataset
   # then list it as a prerequisite.  Zpool's get autorequired by the zfs
   # type.  We just need to autorequire the dataset zfs itself as the zfs type
   # will autorequire all of the zfs parents and zpool.
   autorequire(:zfs) do
 
   # Check if we have datasets in our zone configuration
     if @parameters.include? :dataset
       reqs = []
       # Autorequire each dataset
       self[:dataset].each { |value|
         reqs << value
       }
       reqs
     end
   end
 
   def validate_ip(ip, name)
       IPAddr.new(ip) if ip
   rescue ArgumentError
       self.fail "'#{ip}' is an invalid #{name}"
   end
 
   validate do
     value = self[:ip]
     interface, address, defrouter = value.split(':')
     if self[:iptype] == :shared
       if (interface && address && defrouter.nil?) ||
         (interface && address && defrouter)
         validate_ip(address, "IP address")
         validate_ip(defrouter, "default router")
       else
         self.fail "ip must contain interface name and ip address separated by a \":\""
       end
     else
       self.fail "only interface may be specified when using exclusive IP stack: #{value}" unless interface && address.nil? && defrouter.nil?
     end
 
     self.fail "zone path is required" unless self[:path]
   end
 
   def retrieve
     provider.flush
     if hash = provider.properties and hash[:ensure] != :absent
       result = setstatus(hash)
       result
     else
       # Return all properties as absent.
       return properties.inject({}) do | prophash, property|
         prophash[property] = :absent
         prophash
       end
     end
   end
 
   # Take the results of a listing and set everything appropriately.
   def setstatus(hash)
     prophash = {}
     hash.each do |param, value|
       next if param == :name
       case self.class.attrtype(param)
       when :property
         # Only try to provide values for the properties we're managing
         if prop = self.property(param)
           prophash[prop] = value
         end
       else
         self[param] = value
       end
     end
     prophash
   end
 end
diff --git a/lib/puppet/type/zpool.rb b/lib/puppet/type/zpool.rb
index 40ee8f286..2da713c2b 100755
--- a/lib/puppet/type/zpool.rb
+++ b/lib/puppet/type/zpool.rb
@@ -1,90 +1,91 @@
 module Puppet
   class Property
 
     class VDev < Property
 
       def flatten_and_sort(array)
+        array = [array] unless array.is_a? Array
         array.collect { |a| a.split(' ') }.flatten.sort
       end
 
       def insync?(is)
         return @should == [:absent] if is == :absent
 
         flatten_and_sort(is) == flatten_and_sort(@should)
       end
     end
 
     class MultiVDev < VDev
       def insync?(is)
         return @should == [:absent] if is == :absent
 
         return false unless is.length == @should.length
 
         is.each_with_index { |list, i| return false unless flatten_and_sort(list) == flatten_and_sort(@should[i]) }
 
         #if we made it this far we are in sync
         true
       end
     end
   end
 
   newtype(:zpool) do
     @doc = "Manage zpools. Create and delete zpools. The provider WILL NOT SYNC, only report differences.
 
       Supports vdevs with mirrors, raidz, logs and spares."
 
     ensurable
 
     newproperty(:disk, :array_matching => :all, :parent => Puppet::Property::VDev) do
       desc "The disk(s) for this pool. Can be an array or space separated string"
     end
 
     newproperty(:mirror, :array_matching => :all, :parent => Puppet::Property::MultiVDev) do
       desc "List of all the devices to mirror for this pool. Each mirror should be a
       space separated string:
 
           mirror => [\"disk1 disk2\", \"disk3 disk4\"],
 
       "
 
       validate do |value|
         raise ArgumentError, "mirror names must be provided as string separated, not a comma-separated list" if value.include?(",")
       end
     end
 
     newproperty(:raidz, :array_matching => :all, :parent => Puppet::Property::MultiVDev) do
       desc "List of all the devices to raid for this pool. Should be an array of
       space separated strings:
 
           raidz => [\"disk1 disk2\", \"disk3 disk4\"],
 
       "
 
       validate do |value|
         raise ArgumentError, "raid names must be provided as string separated, not a comma-separated list" if value.include?(",")
       end
     end
 
     newproperty(:spare, :array_matching => :all, :parent => Puppet::Property::VDev) do
       desc "Spare disk(s) for this pool."
     end
 
     newproperty(:log, :array_matching => :all, :parent => Puppet::Property::VDev) do
       desc "Log disks for this pool. (doesn't support mirroring yet)"
     end
 
     newparam(:pool) do
       desc "The name for this pool."
       isnamevar
     end
 
     newparam(:raid_parity) do
       desc "Determines parity when using raidz property."
     end
 
     validate do
       has_should = [:disk, :mirror, :raidz].select { |prop| self.should(prop) }
       self.fail "You cannot specify #{has_should.join(" and ")} on this type (only one)" if has_should.length > 1
     end
   end
 end
diff --git a/spec/unit/indirector/active_record_spec.rb b/spec/unit/indirector/active_record_spec.rb
index 4765cc5ea..4fab17da2 100755
--- a/spec/unit/indirector/active_record_spec.rb
+++ b/spec/unit/indirector/active_record_spec.rb
@@ -1,77 +1,76 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/rails'
 require 'puppet/indirector/active_record'
 
 describe Puppet::Indirector::ActiveRecord do
   before do
     Puppet::Rails.stubs(:init)
 
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
-    @active_record_class = Class.new(Puppet::Indirector::ActiveRecord) do
-      def self.to_s
-        "Mystuff::Testing"
-      end
+    module Testing; end
+    @active_record_class = class Testing::MyActiveRecord < Puppet::Indirector::ActiveRecord
+      self
     end
 
     @ar_model = mock 'ar_model'
 
     @active_record_class.use_ar_model @ar_model
     @terminus = @active_record_class.new
 
     @name = "me"
     @instance = stub 'instance', :name => @name
 
     @request = stub 'request', :key => @name, :instance => @instance
   end
 
   it "should allow declaration of an ActiveRecord model to use" do
     @active_record_class.use_ar_model "foo"
     @active_record_class.ar_model.should == "foo"
   end
 
   describe "when initializing" do
     it "should init Rails" do
       Puppet::Rails.expects(:init)
       @active_record_class.new
     end
   end
 
   describe "when finding an instance" do
     it "should use the ActiveRecord model to find the instance" do
       @ar_model.expects(:find_by_name).with(@name)
 
       @terminus.find(@request)
     end
 
     it "should return nil if no instance is found" do
       @ar_model.expects(:find_by_name).with(@name).returns nil
       @terminus.find(@request).should be_nil
     end
 
     it "should convert the instance to a Puppet object if it is found" do
       instance = mock 'rails_instance'
       instance.expects(:to_puppet).returns "mypuppet"
 
       @ar_model.expects(:find_by_name).with(@name).returns instance
       @terminus.find(@request).should == "mypuppet"
     end
   end
 
   describe "when saving an instance" do
     it "should use the ActiveRecord model to convert the instance into a Rails object and then save that rails object" do
       rails_object = mock 'rails_object'
       @ar_model.expects(:from_puppet).with(@instance).returns rails_object
 
       rails_object.expects(:save)
 
       @terminus.save(@request)
     end
   end
 end
diff --git a/spec/unit/indirector/code_spec.rb b/spec/unit/indirector/code_spec.rb
index 452d009f8..1c9e4d2f1 100755
--- a/spec/unit/indirector/code_spec.rb
+++ b/spec/unit/indirector/code_spec.rb
@@ -1,33 +1,32 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'puppet/indirector/code'
 
 describe Puppet::Indirector::Code do
-  before do
+  before :all do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
-    @code_class = Class.new(Puppet::Indirector::Code) do
-      def self.to_s
-        "Mystuff::Testing"
-      end
+    module Testing; end
+    @code_class = class Testing::MyCode < Puppet::Indirector::Code
+      self
     end
 
     @searcher = @code_class.new
   end
 
   it "should not have a find() method defined" do
     @searcher.should_not respond_to(:find)
   end
 
   it "should not have a save() method defined" do
     @searcher.should_not respond_to(:save)
   end
 
   it "should not have a destroy() method defined" do
     @searcher.should_not respond_to(:destroy)
   end
 end
diff --git a/spec/unit/indirector/direct_file_server_spec.rb b/spec/unit/indirector/direct_file_server_spec.rb
index 8eab4ad76..5d9af626f 100755
--- a/spec/unit/indirector/direct_file_server_spec.rb
+++ b/spec/unit/indirector/direct_file_server_spec.rb
@@ -1,84 +1,83 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-10-24.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/indirector/direct_file_server'
 
 describe Puppet::Indirector::DirectFileServer do
-  before :each do
+  before :all do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
-    @direct_file_class = Class.new(Puppet::Indirector::DirectFileServer) do
-      def self.to_s
-        "Testing::Mytype"
-      end
+    module Testing; end
+    @direct_file_class = class Testing::Mytype < Puppet::Indirector::DirectFileServer
+      self
     end
 
     @server = @direct_file_class.new
 
     @uri = "file:///my/local"
 
     @request = Puppet::Indirector::Request.new(:mytype, :find, @uri)
   end
 
   describe Puppet::Indirector::DirectFileServer, "when finding a single file" do
 
     it "should return nil if the file does not exist" do
       FileTest.expects(:exists?).with("/my/local").returns false
       @server.find(@request).should be_nil
     end
 
     it "should return a Content instance created with the full path to the file if the file exists" do
       FileTest.expects(:exists?).with("/my/local").returns true
       @model.expects(:new).returns(:mycontent)
       @server.find(@request).should == :mycontent
     end
   end
 
   describe Puppet::Indirector::DirectFileServer, "when creating the instance for a single found file" do
 
     before do
       @data = mock 'content'
       @data.stubs(:collect)
       FileTest.expects(:exists?).with("/my/local").returns true
     end
 
     it "should pass the full path to the instance" do
       @model.expects(:new).with { |key, options| key == "/my/local" }.returns(@data)
       @server.find(@request)
     end
 
     it "should pass the :links setting on to the created Content instance if the file exists and there is a value for :links" do
       @model.expects(:new).returns(@data)
       @data.expects(:links=).with(:manage)
 
       @request.stubs(:options).returns(:links => :manage)
       @server.find(@request)
     end
   end
 
   describe Puppet::Indirector::DirectFileServer, "when searching for multiple files" do
     it "should return nil if the file does not exist" do
       FileTest.expects(:exists?).with("/my/local").returns false
       @server.find(@request).should be_nil
     end
 
     it "should use :path2instances from the terminus_helper to return instances if the file exists" do
       FileTest.expects(:exists?).with("/my/local").returns true
       @server.expects(:path2instances)
       @server.search(@request)
     end
 
     it "should pass the original request to :path2instances" do
       FileTest.expects(:exists?).with("/my/local").returns true
       @server.expects(:path2instances).with(@request, "/my/local")
       @server.search(@request)
     end
   end
 end
diff --git a/spec/unit/indirector/exec_spec.rb b/spec/unit/indirector/exec_spec.rb
index d4fb22443..5abb00ae9 100755
--- a/spec/unit/indirector/exec_spec.rb
+++ b/spec/unit/indirector/exec_spec.rb
@@ -1,55 +1,55 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/indirector/exec'
 
 describe Puppet::Indirector::Exec do
-  before do
+  before :all do
     @indirection = stub 'indirection', :name => :testing
     Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
-    @exec_class = Class.new(Puppet::Indirector::Exec) do
-      def self.to_s
-        "Testing::Mytype"
-      end
-
+    module Testing; end
+    @exec_class = class Testing::MyTesting < Puppet::Indirector::Exec
       attr_accessor :command
+      self
     end
+  end
 
+  before :each do
     @searcher = @exec_class.new
     @searcher.command = ["/echo"]
 
     @request = stub 'request', :key => "foo"
   end
 
   it "should throw an exception if the command is not an array" do
     @searcher.command = "/usr/bin/echo"
     proc { @searcher.find(@request) }.should raise_error(Puppet::DevError)
   end
 
   it "should throw an exception if the command is not fully qualified" do
     @searcher.command = ["mycommand"]
     proc { @searcher.find(@request) }.should raise_error(ArgumentError)
   end
 
   it "should execute the command with the object name as the only argument" do
     @searcher.expects(:execute).with(%w{/echo foo})
     @searcher.find(@request)
   end
 
   it "should return the output of the script" do
     @searcher.expects(:execute).with(%w{/echo foo}).returns("whatever")
     @searcher.find(@request).should == "whatever"
   end
 
   it "should return nil when the command produces no output" do
     @searcher.expects(:execute).with(%w{/echo foo}).returns(nil)
     @searcher.find(@request).should be_nil
   end
 
   it "should raise an exception if there's an execution failure" do
     @searcher.expects(:execute).with(%w{/echo foo}).raises(Puppet::ExecutionFailure.new("message"))
 
     lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end
 end
diff --git a/spec/unit/indirector/file_server_spec.rb b/spec/unit/indirector/file_server_spec.rb
index a81d50487..079eba0ae 100755
--- a/spec/unit/indirector/file_server_spec.rb
+++ b/spec/unit/indirector/file_server_spec.rb
@@ -1,266 +1,267 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-10-19.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/indirector/file_server'
 require 'puppet/file_serving/configuration'
 
 describe Puppet::Indirector::FileServer do
 
-  before :each do
+  before :all do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
-    @file_server_class = Class.new(Puppet::Indirector::FileServer) do
-      def self.to_s
-        "Testing::Mytype"
-      end
+    module Testing; end
+    @file_server_class = class Testing::MyFileServer < Puppet::Indirector::FileServer
+      self
     end
+  end
 
+  before :each do
     @file_server = @file_server_class.new
 
     @uri = "puppet://host/my/local/file"
     @configuration = mock 'configuration'
     Puppet::FileServing::Configuration.stubs(:create).returns(@configuration)
 
     @request = Puppet::Indirector::Request.new(:myind, :mymethod, @uri, :environment => "myenv")
   end
 
   describe "when finding files" do
     before do
       @mount = stub 'mount', :find => nil
       @instance = stub('instance', :links= => nil, :collect => nil)
     end
 
     it "should use the configuration to find the mount and relative path" do
       @configuration.expects(:split_path).with(@request)
 
       @file_server.find(@request)
     end
 
     it "should return nil if it cannot find the mount" do
       @configuration.expects(:split_path).with(@request).returns(nil, nil)
 
       @file_server.find(@request).should be_nil
     end
 
     it "should use the mount to find the full path" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }
 
       @file_server.find(@request)
     end
 
     it "should pass the request when finding a file" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| request == @request }
 
       @file_server.find(@request)
     end
 
     it "should return nil if it cannot find a full path" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }.returns nil
 
       @file_server.find(@request).should be_nil
     end
 
     it "should create an instance with the found path" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
       @model.expects(:new).with("/my/file").returns @instance
 
       @file_server.find(@request).should equal(@instance)
     end
 
     it "should set 'links' on the instance if it is set in the request options" do
       @request.options[:links] = true
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
       @model.expects(:new).with("/my/file").returns @instance
 
       @instance.expects(:links=).with(true)
 
       @file_server.find(@request).should equal(@instance)
     end
 
     it "should collect the instance" do
       @request.options[:links] = true
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
       @model.expects(:new).with("/my/file").returns @instance
 
       @instance.expects(:collect)
 
       @file_server.find(@request).should equal(@instance)
     end
   end
 
   describe "when searching for instances" do
     before do
       @mount = stub 'mount', :search => nil
       @instance = stub('instance', :links= => nil, :collect => nil)
     end
 
     it "should use the configuration to search the mount and relative path" do
       @configuration.expects(:split_path).with(@request)
 
       @file_server.search(@request)
     end
 
     it "should return nil if it cannot search the mount" do
       @configuration.expects(:split_path).with(@request).returns(nil, nil)
 
       @file_server.search(@request).should be_nil
     end
 
     it "should use the mount to search for the full paths" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }
 
       @file_server.search(@request)
     end
 
     it "should pass the request" do
       @configuration.stubs(:split_path).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| request == @request }
 
       @file_server.search(@request)
     end
 
     it "should return nil if searching does not find any full paths" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns nil
 
       @file_server.search(@request).should be_nil
     end
 
     it "should create a fileset with each returned path and merge them" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns %w{/one /two}
 
       FileTest.stubs(:exist?).returns true
 
       one = mock 'fileset_one'
       Puppet::FileServing::Fileset.expects(:new).with("/one", @request).returns(one)
       two = mock 'fileset_two'
       Puppet::FileServing::Fileset.expects(:new).with("/two", @request).returns(two)
 
       Puppet::FileServing::Fileset.expects(:merge).with(one, two).returns []
 
       @file_server.search(@request)
     end
 
     it "should create an instance with each path resulting from the merger of the filesets" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
       FileTest.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one", "two" => "/two")
 
       one = stub 'one', :collect => nil
       @model.expects(:new).with("/one", :relative_path => "one").returns one
 
       two = stub 'two', :collect => nil
       @model.expects(:new).with("/two", :relative_path => "two").returns two
 
       # order can't be guaranteed
       result = @file_server.search(@request)
       result.should be_include(one)
       result.should be_include(two)
       result.length.should == 2
     end
 
     it "should set 'links' on the instances if it is set in the request options" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
       FileTest.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
       one = stub 'one', :collect => nil
       @model.expects(:new).with("/one", :relative_path => "one").returns one
       one.expects(:links=).with true
 
       @request.options[:links] = true
 
       @file_server.search(@request)
     end
 
     it "should collect the instances" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, options| key == "rel/path" }.returns []
 
       FileTest.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
       one = mock 'one'
       @model.expects(:new).with("/one", :relative_path => "one").returns one
       one.expects(:collect)
 
       @file_server.search(@request)
     end
   end
 
   describe "when checking authorization" do
     before do
       @request.method = :find
 
       @mount = stub 'mount'
       @configuration.stubs(:split_path).with(@request).returns([@mount, "rel/path"])
       @request.stubs(:node).returns("mynode")
       @request.stubs(:ip).returns("myip")
       @mount.stubs(:allowed?).with("mynode", "myip").returns "something"
     end
 
     it "should return false when destroying" do
       @request.method = :destroy
       @file_server.should_not be_authorized(@request)
     end
 
     it "should return false when saving" do
       @request.method = :save
       @file_server.should_not be_authorized(@request)
     end
 
     it "should use the configuration to find the mount and relative path" do
       @configuration.expects(:split_path).with(@request)
 
       @file_server.authorized?(@request)
     end
 
     it "should return false if it cannot find the mount" do
       @configuration.expects(:split_path).with(@request).returns(nil, nil)
 
       @file_server.should_not be_authorized(@request)
     end
 
     it "should return the results of asking the mount whether the node and IP are authorized" do
       @file_server.authorized?(@request).should == "something"
     end
   end
 end
diff --git a/spec/unit/indirector/file_spec.rb b/spec/unit/indirector/file_spec.rb
index 8fd197eac..96d5b2ae7 100755
--- a/spec/unit/indirector/file_spec.rb
+++ b/spec/unit/indirector/file_spec.rb
@@ -1,181 +1,180 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'puppet/indirector/file'
 
 
 describe Puppet::Indirector::File do
-  before :each do
+  before :all do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
-    @file_class = Class.new(Puppet::Indirector::File) do
-      def self.to_s
-        "Testing::Mytype"
-      end
+    module Testing; end
+    @file_class = class Testing::MyFile < Puppet::Indirector::File
+      self
     end
 
     @searcher = @file_class.new
 
     @path = "/my/file"
     @dir = "/my"
 
     @request = stub 'request', :key => @path
   end
 
   describe "when finding files" do
     it "should provide a method to return file contents at a specified path" do
       @searcher.should respond_to(:find)
     end
 
     it "should use the server data directory plus the indirection name if the run_mode is master" do
       Puppet.run_mode.expects(:master?).returns true
       Puppet.settings.expects(:value).with(:server_datadir).returns "/my/dir"
 
       @searcher.data_directory.should == File.join("/my/dir", "mystuff")
     end
 
     it "should use the client data directory plus the indirection name if the run_mode is not master" do
       Puppet.run_mode.expects(:master?).returns false
       Puppet.settings.expects(:value).with(:client_datadir).returns "/my/dir"
 
       @searcher.data_directory.should == File.join("/my/dir", "mystuff")
     end
 
     it "should use the newest file in the data directory matching the indirection key without extension" do
       @searcher.expects(:data_directory).returns "/data/dir"
       @request.stubs(:key).returns "foo"
       Dir.expects(:glob).with("/data/dir/foo.*").returns %w{/data1.stuff /data2.stuff}
 
       stat1 = stub 'data1', :mtime => (Time.now - 5)
       stat2 = stub 'data2', :mtime => Time.now
       File.expects(:stat).with("/data1.stuff").returns stat1
       File.expects(:stat).with("/data2.stuff").returns stat2
 
       @searcher.latest_path(@request).should == "/data2.stuff"
     end
 
     it "should return nil when no files are found" do
       @searcher.stubs(:latest_path).returns nil
 
       @searcher.find(@request).should be_nil
     end
 
     it "should determine the file format from the file extension" do
       @searcher.file_format("/data2.pson").should == "pson"
     end
 
     it "should fail if the model does not support the file format" do
       @searcher.stubs(:latest_path).returns "/my/file.pson"
 
       @model.expects(:support_format?).with("pson").returns false
 
       lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when saving files" do
     before do
       @content = "my content"
       @file = stub 'file', :content => @content, :path => @path, :name => @path, :render => "mydata"
       @request.stubs(:instance).returns @file
     end
 
     it "should provide a method to save file contents at a specified path" do
       @searcher.should respond_to(:save)
     end
 
     it "should choose the file extension based on the default format of the model" do
       @model.expects(:default_format).returns "pson"
 
       @searcher.serialization_format.should == "pson"
     end
 
     it "should place the file in the data directory, named after the indirection, key, and format" do
       @searcher.stubs(:data_directory).returns "/my/dir"
       @searcher.stubs(:serialization_format).returns "pson"
 
       @request.stubs(:key).returns "foo"
       @searcher.file_path(@request).should == File.join("/my/dir", "foo.pson")
     end
 
     it "should fail intelligently if the file's parent directory does not exist" do
       @searcher.stubs(:file_path).returns "/my/dir/file.pson"
       @searcher.stubs(:serialization_format).returns "pson"
 
       @request.stubs(:key).returns "foo"
       File.expects(:directory?).with(File.join("/my/dir")).returns(false)
 
       proc { @searcher.save(@request) }.should raise_error(Puppet::Error)
     end
 
     it "should render the instance using the file format and print it to the file path" do
       @searcher.stubs(:file_path).returns "/my/file.pson"
       @searcher.stubs(:serialization_format).returns "pson"
 
       File.stubs(:directory?).returns true
 
       @request.instance.expects(:render).with("pson").returns "data"
 
       fh = mock 'filehandle'
       File.expects(:open).with("/my/file.pson", "w").yields fh
       fh.expects(:print).with("data")
 
       @searcher.save(@request)
     end
 
     it "should fail intelligently if a file cannot be written" do
       filehandle = mock 'file'
       File.stubs(:directory?).returns(true)
       File.stubs(:open).yields(filehandle)
       filehandle.expects(:print).raises(ArgumentError)
 
       @searcher.stubs(:file_path).returns "/my/file.pson"
       @model.stubs(:default_format).returns "pson"
 
       @instance.stubs(:render).returns "stuff"
 
       proc { @searcher.save(@request) }.should raise_error(Puppet::Error)
     end
   end
 
   describe "when removing files" do
     it "should provide a method to remove files" do
       @searcher.should respond_to(:destroy)
     end
 
     it "should remove files in all formats found in the data directory that match the request key" do
       @searcher.stubs(:data_directory).returns "/my/dir"
       @request.stubs(:key).returns "me"
 
       Dir.expects(:glob).with(File.join("/my/dir", "me.*")).returns %w{/one /two}
 
       File.expects(:unlink).with("/one")
       File.expects(:unlink).with("/two")
 
       @searcher.destroy(@request)
     end
 
     it "should throw an exception if no file is found" do
       @searcher.stubs(:data_directory).returns "/my/dir"
       @request.stubs(:key).returns "me"
 
       Dir.expects(:glob).with(File.join("/my/dir", "me.*")).returns []
 
       proc { @searcher.destroy(@request) }.should raise_error(Puppet::Error)
     end
 
     it "should fail intelligently if a file cannot be removed" do
       @searcher.stubs(:data_directory).returns "/my/dir"
       @request.stubs(:key).returns "me"
 
       Dir.expects(:glob).with(File.join("/my/dir", "me.*")).returns %w{/one}
 
       File.expects(:unlink).with("/one").raises ArgumentError
 
       proc { @searcher.destroy(@request) }.should raise_error(Puppet::Error)
     end
   end
 end
diff --git a/spec/unit/indirector/ldap_spec.rb b/spec/unit/indirector/ldap_spec.rb
index 2178a8709..ab5dab9ce 100755
--- a/spec/unit/indirector/ldap_spec.rb
+++ b/spec/unit/indirector/ldap_spec.rb
@@ -1,139 +1,138 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/indirector/ldap'
 
 describe Puppet::Indirector::Ldap do
   before do
     @indirection = stub 'indirection', :name => :testing
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
-    @ldap_class = Class.new(Puppet::Indirector::Ldap) do
-      def self.to_s
-        "Testing::Mytype"
-      end
+    module Testing; end
+    @ldap_class = class Testing::MyLdap < Puppet::Indirector::Ldap
+      self
     end
 
     @connection = mock 'ldap'
 
     @searcher = @ldap_class.new
   end
 
   describe "when searching ldap" do
     before do
       # Stub everything, and we can selectively replace with an expect as
       # we need to for testing.
       @searcher.stubs(:connection).returns(@connection)
       @searcher.stubs(:search_filter).returns(:filter)
       @searcher.stubs(:search_base).returns(:base)
       @searcher.stubs(:process)
 
       @request = stub 'request', :key => "yay"
     end
 
     it "should call the ldapsearch method with the search filter" do
       @searcher.expects(:search_filter).with("yay").returns("yay's filter")
       @searcher.expects(:ldapsearch).with("yay's filter")
       @searcher.find @request
     end
 
     it "should fail if no block is passed to the ldapsearch method" do
       proc { @searcher.ldapsearch("blah") }.should raise_error(ArgumentError)
     end
 
     it "should use the results of the ldapbase method as the ldap search base" do
       @searcher.stubs(:search_base).returns("mybase")
       @connection.expects(:search).with do |*args|
         args[0].should == "mybase"
         true
       end
       @searcher.find @request
     end
 
     it "should default to the value of the :search_base setting as the result of the ldapbase method" do
       Puppet.expects(:[]).with(:ldapbase).returns("myldapbase")
       searcher = @ldap_class.new
       searcher.search_base.should == "myldapbase"
     end
 
     it "should use the results of the :search_attributes method as the list of attributes to return" do
       @searcher.stubs(:search_attributes).returns(:myattrs)
       @connection.expects(:search).with do |*args|
         args[3].should == :myattrs
         true
       end
       @searcher.find @request
     end
 
     it "should use depth 2 when searching" do
       @connection.expects(:search).with do |*args|
         args[1].should == 2
         true
       end
       @searcher.find @request
     end
 
     it "should call process() on the first found entry" do
       @connection.expects(:search).yields("myresult")
       @searcher.expects(:process).with("myresult")
       @searcher.find @request
     end
 
     it "should reconnect and retry the search if there is a failure" do
       run = false
       @connection.stubs(:search).with do |*args|
         if run
           true
         else
           run = true
           raise "failed"
         end
       end.yields("myresult")
       @searcher.expects(:process).with("myresult")
 
       @searcher.find @request
     end
 
     it "should not reconnect on failure more than once" do
       count = 0
       @connection.stubs(:search).with do |*args|
         count += 1
         raise ArgumentError, "yay"
       end
       proc { @searcher.find(@request) }.should raise_error(Puppet::Error)
       count.should == 2
     end
 
     it "should return true if an entry is found" do
       @connection.expects(:search).yields("result")
       @searcher.ldapsearch("whatever") { |r| }.should be_true
     end
   end
 
   describe "when connecting to ldap", :if => Puppet.features.ldap? do
     it "should create and start a Util::Ldap::Connection instance" do
       conn = mock 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
       @searcher.connection.should == "myconn"
     end
 
     it "should only create the ldap connection when asked for it the first time" do
       conn = mock 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
       @searcher.connection
     end
 
     it "should cache the connection" do
       conn = mock 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
       @searcher.connection.should equal(@searcher.connection)
     end
   end
 
   describe "when reconnecting to ldap", :if => (Puppet.features.root? and Facter.value("hostname") == "culain") do
     it "should reconnect to ldap when connections are lost"
   end
 end
diff --git a/spec/unit/indirector/memory_spec.rb b/spec/unit/indirector/memory_spec.rb
index f9010326f..751adb1b6 100755
--- a/spec/unit/indirector/memory_spec.rb
+++ b/spec/unit/indirector/memory_spec.rb
@@ -1,29 +1,28 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'puppet/indirector/memory'
 
 require 'shared_behaviours/memory_terminus'
 
 describe Puppet::Indirector::Memory do
   it_should_behave_like "A Memory Terminus"
 
   before do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
-    @memory_class = Class.new(Puppet::Indirector::Memory) do
-      def self.to_s
-        "Mystuff::Testing"
-      end
+    module Testing; end
+    @memory_class = class Testing::MyMemory < Puppet::Indirector::Memory
+      self
     end
 
     @searcher = @memory_class.new
     @name = "me"
     @instance = stub 'instance', :name => @name
 
     @request = stub 'request', :key => @name, :instance => @instance
   end
 end
diff --git a/spec/unit/indirector/plain_spec.rb b/spec/unit/indirector/plain_spec.rb
index 54c0233f8..dfaa701bd 100755
--- a/spec/unit/indirector/plain_spec.rb
+++ b/spec/unit/indirector/plain_spec.rb
@@ -1,29 +1,28 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'puppet/indirector/plain'
 
 describe Puppet::Indirector::Plain do
   before do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
-    @plain_class = Class.new(Puppet::Indirector::Plain) do
-      def self.to_s
-        "Mystuff::Testing"
-      end
+    module Testing; end
+    @plain_class = class Testing::MyPlain < Puppet::Indirector::Plain
+      self
     end
 
     @searcher = @plain_class.new
 
     @request = stub 'request', :key => "yay"
   end
 
   it "should return return an instance of the indirected model" do
     object = mock 'object'
     @model.expects(:new).with(@request.key).returns object
     @searcher.find(@request).should equal(object)
   end
 end
diff --git a/spec/unit/indirector/queue_spec.rb b/spec/unit/indirector/queue_spec.rb
index 49e5e1015..6f5b44b4c 100755
--- a/spec/unit/indirector/queue_spec.rb
+++ b/spec/unit/indirector/queue_spec.rb
@@ -1,123 +1,122 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'puppet/indirector/queue'
 
 class Puppet::Indirector::Queue::TestClient
 end
 
 class FooExampleData
   attr_accessor :name
 
   def self.pson_create(pson)
     new(pson['data'].to_sym)
   end
 
   def initialize(name = nil)
     @name = name if name
   end
 
   def render(format = :pson)
     to_pson
   end
 
   def to_pson(*args)
     {:type => self.class.to_s, :data => name}.to_pson(*args)
   end
 end
 
 describe Puppet::Indirector::Queue, :if => Puppet.features.pson? do
   before :each do
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :my_queue, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).with(:my_queue).returns(@indirection)
-    @store_class = Class.new(Puppet::Indirector::Queue) do
-      def self.to_s
-        'MyQueue::MyType'
-      end
+    module MyQueue; end
+    @store_class = class MyQueue::MyType < Puppet::Indirector::Queue
+      self
     end
     @store = @store_class.new
 
     @subject_class = FooExampleData
     @subject = @subject_class.new
     @subject.name = :me
 
     Puppet[:queue_type] = :test_client
     Puppet::Util::Queue.stubs(:queue_type_to_class).with(:test_client).returns(Puppet::Indirector::Queue::TestClient)
 
     @request = stub 'request', :key => :me, :instance => @subject
   end
 
   it "should require PSON" do
     Puppet.features.expects(:pson?).returns false
 
     lambda { @store_class.new }.should raise_error(ArgumentError)
   end
 
   it 'should use the correct client type and queue' do
     @store.queue.should == :my_queue
     @store.client.should be_an_instance_of(Puppet::Indirector::Queue::TestClient)
   end
 
   describe "when saving" do
     it 'should render the instance using pson' do
       @subject.expects(:render).with(:pson)
       @store.client.stubs(:send_message)
       @store.save(@request)
     end
 
     it "should send the rendered message to the appropriate queue on the client" do
       @subject.expects(:render).returns "mypson"
 
       @store.client.expects(:send_message).with(:my_queue, "mypson")
 
       @store.save(@request)
     end
 
     it "should catch any exceptions raised" do
       @store.client.expects(:send_message).raises ArgumentError
 
       lambda { @store.save(@request) }.should raise_error(Puppet::Error)
     end
   end
 
   describe "when subscribing to the queue" do
     before do
       @store_class.stubs(:model).returns @model
     end
 
     it "should use the model's Format support to intern the message from pson" do
       @model.expects(:convert_from).with(:pson, "mymessage")
 
       @store_class.client.expects(:subscribe).yields("mymessage")
       @store_class.subscribe {|o| o }
     end
 
     it "should yield each interned received message" do
       @model.stubs(:convert_from).returns "something"
 
       @subject_two = @subject_class.new
       @subject_two.name = :too
 
       @store_class.client.expects(:subscribe).with(:my_queue).multiple_yields(@subject, @subject_two)
 
       received = []
       @store_class.subscribe do |obj|
         received.push(obj)
       end
 
       received.should == %w{something something}
     end
 
     it "should log but not propagate errors" do
       @store_class.client.expects(:subscribe).yields("foo")
       @store_class.expects(:intern).raises(ArgumentError)
       expect { @store_class.subscribe {|o| o } }.should_not raise_error
 
       @logs.length.should == 1
       @logs.first.message.should =~ /Error occured with subscription to queue my_queue for indirection my_queue: ArgumentError/
       @logs.first.level.should == :err
     end
   end
 end
 
diff --git a/spec/unit/indirector/rest_spec.rb b/spec/unit/indirector/rest_spec.rb
index 547e68dd3..326d85f9d 100755
--- a/spec/unit/indirector/rest_spec.rb
+++ b/spec/unit/indirector/rest_spec.rb
@@ -1,491 +1,499 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'puppet/indirector/rest'
 
 shared_examples_for "a REST http call" do
   it "should accept a path" do
     lambda { @search.send(@method, *@arguments) }.should_not raise_error(ArgumentError)
   end
 
   it "should require a path" do
     lambda { @searcher.send(@method) }.should raise_error(ArgumentError)
   end
 
   it "should return the results of deserializing the response to the request" do
     conn = mock 'connection'
     conn.stubs(:put).returns @response
     conn.stubs(:delete).returns @response
     conn.stubs(:get).returns @response
     Puppet::Network::HttpPool.stubs(:http_instance).returns conn
 
     @searcher.expects(:deserialize).with(@response).returns "myobject"
 
     @searcher.send(@method, *@arguments).should == 'myobject'
   end
 end
 
 describe Puppet::Indirector::REST do
-  before do
+  before :all do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = stub('model', :supported_formats => %w{}, :convert_from => nil)
     @instance = stub('model instance', :name= => nil)
     @indirection = stub('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
-    Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+    Puppet::Indirector::Indirection.expects(:instance).returns(@indirection)
 
-    @rest_class = Class.new(Puppet::Indirector::REST) do
-      def self.to_s
-        "This::Is::A::Test::Class"
+    module This
+      module Is
+        module A
+          module Test
+          end
+        end
       end
     end
+    @rest_class = class This::Is::A::Test::Class < Puppet::Indirector::REST
+      self
+    end
+  end
 
+  before :each do
     @response = stub('mock response', :body => 'result', :code => "200")
     @response.stubs(:[]).with('content-type').returns "text/plain"
     @response.stubs(:[]).with('content-encoding').returns nil
 
     @searcher = @rest_class.new
     @searcher.stubs(:model).returns @model
   end
 
   it "should include the v1 REST API module" do
     Puppet::Indirector::REST.ancestors.should be_include(Puppet::Network::HTTP::API::V1)
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its server" do
     @rest_class.should respond_to(:use_server_setting)
   end
 
   it "should use any specified setting to pick the server" do
     @rest_class.expects(:server_setting).returns :servset
     Puppet.settings.expects(:value).with(:servset).returns "myserver"
     @rest_class.server.should == "myserver"
   end
 
   it "should default to :server for the server setting" do
     @rest_class.expects(:server_setting).returns nil
     Puppet.settings.expects(:value).with(:server).returns "myserver"
     @rest_class.server.should == "myserver"
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its port" do
     @rest_class.should respond_to(:use_port_setting)
   end
 
   it "should use any specified setting to pick the port" do
     @rest_class.expects(:port_setting).returns :servset
     Puppet.settings.expects(:value).with(:servset).returns "321"
     @rest_class.port.should == 321
   end
 
   it "should default to :port for the port setting" do
     @rest_class.expects(:port_setting).returns nil
     Puppet.settings.expects(:value).with(:masterport).returns "543"
     @rest_class.port.should == 543
   end
 
   describe "when deserializing responses" do
     it "should return nil if the response code is 404" do
       response = mock 'response'
       response.expects(:code).returns "404"
 
       @searcher.deserialize(response).should be_nil
     end
 
     [300,400,403,405,500,501,502,503,504].each { |rc|
       describe "when the response code is #{rc}" do
         before :each do
           @model.expects(:convert_from).never
 
           @response = mock 'response'
           @response.stubs(:code).returns rc.to_s
           @response.stubs(:[]).with('content-encoding').returns nil
           @response.stubs(:message).returns "There was a problem (header)"
         end
 
         it "should fail" do
           @response.stubs(:body).returns nil
           lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError)
         end
 
         it "should take the error message from the body, if present" do
           @response.stubs(:body).returns "There was a problem (body)"
           lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (body)")
         end
 
         it "should take the error message from the response header if the body is empty" do
           @response.stubs(:body).returns ""
           lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (header)")
         end
 
         it "should take the error message from the response header if the body is absent" do
           @response.stubs(:body).returns nil
           lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (header)")
         end
 
         describe "and with http compression" do
           it "should uncompress the body" do
             @response.stubs(:body).returns("compressed body")
             @searcher.expects(:uncompress_body).with(@response).returns("uncompressed")
             lambda { @searcher.deserialize(@response) }.should raise_error { |e| e.message =~ /uncompressed/ }
           end
         end
       end
     }
 
     it "should return the results of converting from the format specified by the content-type header if the response code is in the 200s" do
       @model.expects(:convert_from).with("myformat", "mydata").returns "myobject"
 
       response = mock 'response'
       response.stubs(:[]).with("content-type").returns "myformat"
       response.stubs(:[]).with("content-encoding").returns nil
       response.stubs(:body).returns "mydata"
       response.stubs(:code).returns "200"
 
       @searcher.deserialize(response).should == "myobject"
     end
 
     it "should convert and return multiple instances if the return code is in the 200s and 'multiple' is specified" do
       @model.expects(:convert_from_multiple).with("myformat", "mydata").returns "myobjects"
 
       response = mock 'response'
       response.stubs(:[]).with("content-type").returns "myformat"
       response.stubs(:[]).with("content-encoding").returns nil
       response.stubs(:body).returns "mydata"
       response.stubs(:code).returns "200"
 
       @searcher.deserialize(response, true).should == "myobjects"
     end
 
     it "should strip the content-type header to keep only the mime-type" do
       @model.expects(:convert_from).with("text/plain", "mydata").returns "myobject"
 
       response = mock 'response'
       response.stubs(:[]).with("content-type").returns "text/plain; charset=utf-8"
       response.stubs(:[]).with("content-encoding").returns nil
       response.stubs(:body).returns "mydata"
       response.stubs(:code).returns "200"
 
       @searcher.deserialize(response)
     end
 
     it "should uncompress the body" do
       @model.expects(:convert_from).with("myformat", "uncompressed mydata").returns "myobject"
 
       response = mock 'response'
       response.stubs(:[]).with("content-type").returns "myformat"
       response.stubs(:body).returns "compressed mydata"
       response.stubs(:code).returns "200"
 
       @searcher.expects(:uncompress_body).with(response).returns("uncompressed mydata")
 
       @searcher.deserialize(response).should == "myobject"
     end
   end
 
   describe "when creating an HTTP client" do
     before do
       Puppet.settings.stubs(:value).returns("rest_testing")
     end
 
     it "should use the class's server and port if the indirection request provides neither" do
       @request = stub 'request', :key => "foo", :server => nil, :port => nil
       @searcher.class.expects(:port).returns 321
       @searcher.class.expects(:server).returns "myserver"
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       @searcher.network(@request).should == "myconn"
     end
 
     it "should use the server from the indirection request if one is present" do
       @request = stub 'request', :key => "foo", :server => "myserver", :port => nil
       @searcher.class.stubs(:port).returns 321
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       @searcher.network(@request).should == "myconn"
     end
 
     it "should use the port from the indirection request if one is present" do
       @request = stub 'request', :key => "foo", :server => nil, :port => 321
       @searcher.class.stubs(:server).returns "myserver"
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       @searcher.network(@request).should == "myconn"
     end
   end
 
   describe "when doing a find" do
     before :each do
       @connection = stub('mock http connection', :get => @response)
       @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
       # Use a key with spaces, so we can test escaping
       @request = Puppet::Indirector::Request.new(:foo, :find, "foo bar")
     end
 
     it "should call the GET http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:get).returns @response
       @searcher.find(@request)
     end
 
     it "should deserialize and return the http response, setting name" do
       @connection.expects(:get).returns @response
 
       instance = stub 'object'
       instance.expects(:name=)
       @searcher.expects(:deserialize).with(@response).returns instance
 
       @searcher.find(@request).should == instance
     end
 
     it "should deserialize and return the http response, and not require name=" do
       @connection.expects(:get).returns @response
 
       instance = stub 'object'
       @searcher.expects(:deserialize).with(@response).returns instance
 
       @searcher.find(@request).should == instance
     end
 
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
       @connection.expects(:get).with { |path, args| path == "/my/uri" }.returns(@response)
       @searcher.find(@request)
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
       @searcher.model.expects(:supported_formats).returns %w{supported formats}
       @searcher.find(@request)
     end
 
     it "should add Accept-Encoding header" do
       @searcher.expects(:add_accept_encoding).returns({"accept-encoding" => "gzip"})
 
       @connection.expects(:get).with { |path, args| args["accept-encoding"] == "gzip" }.returns(@response)
       @searcher.find(@request)
     end
 
     it "should deserialize and return the network response" do
       @searcher.expects(:deserialize).with(@response).returns @instance
       @searcher.find(@request).should equal(@instance)
     end
 
     it "should set the name of the resulting instance to the asked-for name" do
       @searcher.expects(:deserialize).with(@response).returns @instance
       @instance.expects(:name=).with "foo bar"
       @searcher.find(@request)
     end
 
     it "should generate an error when result data deserializes fails" do
       @searcher.expects(:deserialize).raises(ArgumentError)
       lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when doing a head" do
     before :each do
       @connection = stub('mock http connection', :head => @response)
       @searcher.stubs(:network).returns(@connection)
 
       # Use a key with spaces, so we can test escaping
       @request = Puppet::Indirector::Request.new(:foo, :head, "foo bar")
     end
 
     it "should call the HEAD http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:head).returns @response
       @searcher.head(@request)
     end
 
     it "should return true if there was a successful http response" do
       @connection.expects(:head).returns @response
       @response.stubs(:code).returns "200"
 
       @searcher.head(@request).should == true
     end
 
     it "should return false if there was a successful http response" do
       @connection.expects(:head).returns @response
       @response.stubs(:code).returns "404"
 
       @searcher.head(@request).should == false
     end
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
       @connection.expects(:head).with { |path, args| path == "/my/uri" }.returns(@response)
       @searcher.head(@request)
     end
   end
 
   describe "when doing a search" do
     before :each do
       @connection = stub('mock http connection', :get => @response)
       @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
       @model.stubs(:convert_from_multiple)
 
       @request = Puppet::Indirector::Request.new(:foo, :search, "foo bar")
     end
 
     it "should call the GET http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:get).returns @response
       @searcher.search(@request)
     end
 
     it "should deserialize as multiple instances and return the http response" do
       @connection.expects(:get).returns @response
       @searcher.expects(:deserialize).with(@response, true).returns "myobject"
 
       @searcher.search(@request).should == 'myobject'
     end
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/mys/uri"
       @connection.expects(:get).with { |path, args| path == "/mys/uri" }.returns(@response)
       @searcher.search(@request)
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
       @searcher.model.expects(:supported_formats).returns %w{supported formats}
       @searcher.search(@request)
     end
 
     it "should return an empty array if serialization returns nil" do
       @model.stubs(:convert_from_multiple).returns nil
 
       @searcher.search(@request).should == []
     end
 
     it "should generate an error when result data deserializes fails" do
       @searcher.expects(:deserialize).raises(ArgumentError)
       lambda { @searcher.search(@request) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when doing a destroy" do
     before :each do
       @connection = stub('mock http connection', :delete => @response)
       @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
       @request = Puppet::Indirector::Request.new(:foo, :destroy, "foo bar")
     end
 
     it "should call the DELETE http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:delete).returns @response
       @searcher.destroy(@request)
     end
 
     it "should fail if any options are provided, since DELETE apparently does not support query options" do
       @request.stubs(:options).returns(:one => "two", :three => "four")
 
       lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
     end
 
     it "should deserialize and return the http response" do
       @connection.expects(:delete).returns @response
       @searcher.expects(:deserialize).with(@response).returns "myobject"
 
       @searcher.destroy(@request).should == 'myobject'
     end
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
       @connection.expects(:delete).with { |path, args| path == "/my/uri" }.returns(@response)
       @searcher.destroy(@request)
     end
 
     it "should not include the query string" do
       @connection.stubs(:delete).returns @response
       @searcher.destroy(@request)
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       @connection.expects(:delete).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
       @searcher.model.expects(:supported_formats).returns %w{supported formats}
       @searcher.destroy(@request)
     end
 
     it "should deserialize and return the network response" do
       @searcher.expects(:deserialize).with(@response).returns @instance
       @searcher.destroy(@request).should equal(@instance)
     end
 
     it "should generate an error when result data deserializes fails" do
       @searcher.expects(:deserialize).raises(ArgumentError)
       lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when doing a save" do
     before :each do
       @connection = stub('mock http connection', :put => @response)
       @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
       @instance = stub 'instance', :render => "mydata", :mime => "mime"
       @request = Puppet::Indirector::Request.new(:foo, :save, "foo bar")
       @request.instance = @instance
     end
 
     it "should call the PUT http method on a network connection" do
       @searcher.expects(:network).returns @connection
       @connection.expects(:put).returns @response
       @searcher.save(@request)
     end
 
     it "should fail if any options are provided, since DELETE apparently does not support query options" do
       @request.stubs(:options).returns(:one => "two", :three => "four")
 
       lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
     end
 
     it "should use the URI generated by the Handler module" do
       @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
       @connection.expects(:put).with { |path, args| path == "/my/uri" }.returns(@response)
       @searcher.save(@request)
     end
 
     it "should serialize the instance using the default format and pass the result as the body of the request" do
       @instance.expects(:render).returns "serial_instance"
       @connection.expects(:put).with { |path, data, args| data == "serial_instance" }.returns @response
 
       @searcher.save(@request)
     end
 
     it "should deserialize and return the http response" do
       @connection.expects(:put).returns @response
       @searcher.expects(:deserialize).with(@response).returns "myobject"
 
       @searcher.save(@request).should == 'myobject'
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       @connection.expects(:put).with { |path, data, args| args["Accept"] == "supported, formats" }.returns(@response)
 
       @searcher.model.expects(:supported_formats).returns %w{supported formats}
       @searcher.save(@request)
     end
 
     it "should provide a Content-Type header containing the mime-type of the sent object" do
       @connection.expects(:put).with { |path, data, args| args['Content-Type'] == "mime" }.returns(@response)
 
       @instance.expects(:mime).returns "mime"
       @searcher.save(@request)
     end
 
     it "should deserialize and return the network response" do
       @searcher.expects(:deserialize).with(@response).returns @instance
       @searcher.save(@request).should equal(@instance)
     end
 
     it "should generate an error when result data deserializes fails" do
       @searcher.expects(:deserialize).raises(ArgumentError)
       lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
     end
   end
 end
diff --git a/spec/unit/indirector/ssl_file_spec.rb b/spec/unit/indirector/ssl_file_spec.rb
index 4549127f9..ca97cf49e 100755
--- a/spec/unit/indirector/ssl_file_spec.rb
+++ b/spec/unit/indirector/ssl_file_spec.rb
@@ -1,281 +1,282 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2008-3-10.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/indirector/ssl_file'
 
 describe Puppet::Indirector::SslFile do
-  before do
-    @model = mock 'model'
+  before :all do
     @indirection = stub 'indirection', :name => :testing, :model => @model
     Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
-    @file_class = Class.new(Puppet::Indirector::SslFile) do
-      def self.to_s
-        "Testing::Mytype"
-      end
+    module Testing; end
+    @file_class = class Testing::MyType < Puppet::Indirector::SslFile
+      self
     end
+  end
+  before :each do
+    @model = mock 'model'
 
     @setting = :certdir
     @file_class.store_in @setting
     @path = "/tmp/my_directory"
     Puppet[:noop] = false
     Puppet[@setting] = @path
     Puppet[:trace] = false
   end
 
   it "should use :main and :ssl upon initialization" do
     Puppet.settings.expects(:use).with(:main, :ssl)
     @file_class.new
   end
 
   it "should return a nil collection directory if no directory setting has been provided" do
     @file_class.store_in nil
     @file_class.collection_directory.should be_nil
   end
 
   it "should return a nil file location if no location has been provided" do
     @file_class.store_at nil
     @file_class.file_location.should be_nil
   end
 
   it "should fail if no store directory or file location has been set" do
     @file_class.store_in nil
     @file_class.store_at nil
     lambda { @file_class.new }.should raise_error(Puppet::DevError)
   end
 
   describe "when managing ssl files" do
     before do
       Puppet.settings.stubs(:use)
       @searcher = @file_class.new
 
       @cert = stub 'certificate', :name => "myname"
       @certpath = File.join(@path, "myname.pem")
 
       @request = stub 'request', :key => @cert.name, :instance => @cert
     end
 
     it "should consider the file a ca file if the name is equal to what the SSL::Host class says is the CA name" do
       Puppet::SSL::Host.expects(:ca_name).returns "amaca"
       @searcher.should be_ca("amaca")
     end
 
     describe "when choosing the location for certificates" do
       it "should set them at the ca setting's path if a ca setting is available and the name resolves to the CA name" do
         @file_class.store_in nil
         @file_class.store_at :mysetting
         @file_class.store_ca_at :casetting
 
         Puppet.settings.stubs(:value).with(:casetting).returns "/ca/file"
 
         @searcher.expects(:ca?).with(@cert.name).returns true
         @searcher.path(@cert.name).should == "/ca/file"
       end
 
       it "should set them at the file location if a file setting is available" do
         @file_class.store_in nil
         @file_class.store_at :mysetting
 
         Puppet.settings.stubs(:value).with(:mysetting).returns "/some/file"
 
         @searcher.path(@cert.name).should == "/some/file"
       end
 
       it "should set them in the setting directory, with the certificate name plus '.pem', if a directory setting is available" do
         @searcher.path(@cert.name).should == @certpath
       end
     end
 
     describe "when finding certificates on disk" do
       describe "and no certificate is present" do
         before do
           # Stub things so the case management bits work.
           FileTest.stubs(:exist?).with(File.dirname(@certpath)).returns false
           FileTest.expects(:exist?).with(@certpath).returns false
         end
 
         it "should return nil" do
           @searcher.find(@request).should be_nil
         end
       end
 
       describe "and a certificate is present" do
         before do
           FileTest.expects(:exist?).with(@certpath).returns true
         end
 
         it "should return an instance of the model, which it should use to read the certificate" do
           cert = mock 'cert'
           model = mock 'model'
           @file_class.stubs(:model).returns model
 
           model.expects(:new).with("myname").returns cert
           cert.expects(:read).with(@certpath)
           @searcher.find(@request).should equal(cert)
         end
       end
 
       describe "and a certificate is present but has uppercase letters" do
         before do
           @request = stub 'request', :key => "myhost"
         end
 
         # This is kind of more an integration test; it's for #1382, until
         # the support for upper-case certs can be removed around mid-2009.
         it "should rename the existing file to the lower-case path" do
           @path = @searcher.path("myhost")
           FileTest.expects(:exist?).with(@path).returns(false)
           dir, file = File.split(@path)
           FileTest.expects(:exist?).with(dir).returns true
           Dir.expects(:entries).with(dir).returns [".", "..", "something.pem", file.upcase]
 
           File.expects(:rename).with(File.join(dir, file.upcase), @path)
 
           cert = mock 'cert'
           model = mock 'model'
           @searcher.stubs(:model).returns model
           @searcher.model.expects(:new).with("myhost").returns cert
           cert.expects(:read).with(@path)
 
           @searcher.find(@request)
         end
       end
     end
 
     describe "when saving certificates to disk" do
       before do
         FileTest.stubs(:directory?).returns true
         FileTest.stubs(:writable?).returns true
       end
 
       it "should fail if the directory is absent" do
         FileTest.expects(:directory?).with(File.dirname(@certpath)).returns false
         lambda { @searcher.save(@request) }.should raise_error(Puppet::Error)
       end
 
       it "should fail if the directory is not writeable" do
         FileTest.stubs(:directory?).returns true
         FileTest.expects(:writable?).with(File.dirname(@certpath)).returns false
         lambda { @searcher.save(@request) }.should raise_error(Puppet::Error)
       end
 
       it "should save to the path the output of converting the certificate to a string" do
         fh = mock 'filehandle'
         fh.expects(:print).with("mycert")
 
         @searcher.stubs(:write).yields fh
         @cert.expects(:to_s).returns "mycert"
 
         @searcher.save(@request)
       end
 
       describe "and a directory setting is set" do
         it "should use the Settings class to write the file" do
           @searcher.class.store_in @setting
           fh = mock 'filehandle'
           fh.stubs :print
           Puppet.settings.expects(:writesub).with(@setting, @certpath).yields fh
 
           @searcher.save(@request)
         end
       end
 
       describe "and a file location is set" do
         it "should use the filehandle provided by the Settings" do
           @searcher.class.store_at @setting
 
           fh = mock 'filehandle'
           fh.stubs :print
           Puppet.settings.expects(:write).with(@setting).yields fh
           @searcher.save(@request)
         end
       end
 
       describe "and the name is the CA name and a ca setting is set" do
         it "should use the filehandle provided by the Settings" do
           @searcher.class.store_at @setting
           @searcher.class.store_ca_at :castuff
           Puppet.settings.stubs(:value).with(:castuff).returns "castuff stub"
 
           fh = mock 'filehandle'
           fh.stubs :print
           Puppet.settings.expects(:write).with(:castuff).yields fh
           @searcher.stubs(:ca?).returns true
           @searcher.save(@request)
         end
       end
     end
 
     describe "when destroying certificates" do
       describe "that do not exist" do
         before do
           FileTest.expects(:exist?).with(@certpath).returns false
         end
 
         it "should return false" do
           @searcher.destroy(@request).should be_false
         end
       end
 
       describe "that exist" do
         before do
           FileTest.expects(:exist?).with(@certpath).returns true
         end
 
         it "should unlink the certificate file" do
           File.expects(:unlink).with(@certpath)
           @searcher.destroy(@request)
         end
 
         it "should log that is removing the file" do
           File.stubs(:exist?).returns true
           File.stubs(:unlink)
           Puppet.expects(:notice)
           @searcher.destroy(@request)
         end
       end
     end
 
     describe "when searching for certificates" do
       before do
         @model = mock 'model'
         @file_class.stubs(:model).returns @model
       end
       it "should return a certificate instance for all files that exist" do
         Dir.expects(:entries).with(@path).returns %w{one.pem two.pem}
 
         one = stub 'one', :read => nil
         two = stub 'two', :read => nil
 
         @model.expects(:new).with("one").returns one
         @model.expects(:new).with("two").returns two
 
         @searcher.search(@request).should == [one, two]
       end
 
       it "should read each certificate in using the model's :read method" do
         Dir.expects(:entries).with(@path).returns %w{one.pem}
 
         one = stub 'one'
         one.expects(:read).with(File.join(@path, "one.pem"))
 
         @model.expects(:new).with("one").returns one
 
         @searcher.search(@request)
       end
 
       it "should skip any files that do not match /\.pem$/" do
         Dir.expects(:entries).with(@path).returns %w{. .. one.pem}
 
         one = stub 'one', :read => nil
 
         @model.expects(:new).with("one").returns one
 
         @searcher.search(@request)
       end
     end
   end
 end
diff --git a/spec/unit/indirector/yaml_spec.rb b/spec/unit/indirector/yaml_spec.rb
index 35017991b..188e300d6 100755
--- a/spec/unit/indirector/yaml_spec.rb
+++ b/spec/unit/indirector/yaml_spec.rb
@@ -1,158 +1,159 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/indirector/yaml'
 
 describe Puppet::Indirector::Yaml, " when choosing file location" do
-  before :each do
+  before :all do
     @indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
-    Puppet::Indirector::Indirection.stubs(:instance).with(:my_yaml).returns(@indirection)
-    @store_class = Class.new(Puppet::Indirector::Yaml) do
-      def self.to_s
-        "MyYaml::MyType"
-      end
+    Puppet::Indirector::Indirection.expects(:instance).with(:my_yaml).returns(@indirection)
+    module MyYaml; end
+    @store_class = class MyYaml::MyType < Puppet::Indirector::Yaml
+      self
     end
+  end
+  before :each do
     @store = @store_class.new
 
     @subject = Object.new
     @subject.singleton_class.send(:attr_accessor, :name)
     @subject.name = :me
 
     @dir = "/what/ever"
     Puppet.settings.stubs(:value).returns("fakesettingdata")
     Puppet.settings.stubs(:value).with(:clientyamldir).returns(@dir)
     Puppet.run_mode.stubs(:master?).returns false
 
     @request = stub 'request', :key => :me, :instance => @subject
   end
 
   describe Puppet::Indirector::Yaml, " when choosing file location" do
     it "should use the server_datadir if the run_mode is master" do
       Puppet.run_mode.expects(:master?).returns true
       Puppet.settings.expects(:value).with(:yamldir).returns "/server/yaml/dir"
       @store.path(:me).should =~ %r{^/server/yaml/dir}
     end
 
     it "should use the client yamldir if the run_mode is not master" do
       Puppet.run_mode.expects(:master?).returns false
       Puppet.settings.expects(:value).with(:clientyamldir).returns "/client/yaml/dir"
       @store.path(:me).should =~ %r{^/client/yaml/dir}
     end
 
     it "should use the extension if one is specified" do
       Puppet.run_mode.expects(:master?).returns true
       Puppet.settings.expects(:value).with(:yamldir).returns "/server/yaml/dir"
       @store.path(:me,'.farfignewton').should =~ %r{\.farfignewton$}
     end
 
     it "should assume an extension of .yaml if none is specified" do
       Puppet.run_mode.expects(:master?).returns true
       Puppet.settings.expects(:value).with(:yamldir).returns "/server/yaml/dir"
       @store.path(:me).should =~ %r{\.yaml$}
     end
 
     it "should store all files in a single file root set in the Puppet defaults" do
       @store.path(:me).should =~ %r{^#{@dir}}
     end
 
     it "should use the terminus name for choosing the subdirectory" do
       @store.path(:me).should =~ %r{^#{@dir}/my_yaml}
     end
 
     it "should use the object's name to determine the file name" do
       @store.path(:me).should =~ %r{me.yaml$}
     end
   end
 
   describe Puppet::Indirector::Yaml, " when storing objects as YAML" do
     it "should only store objects that respond to :name" do
       @request.stubs(:instance).returns Object.new
       proc { @store.save(@request) }.should raise_error(ArgumentError)
     end
 
     it "should convert Ruby objects to YAML and write them to disk using a write lock" do
       yaml = @subject.to_yaml
       file = mock 'file'
       path = @store.send(:path, @subject.name)
       FileTest.expects(:exist?).with(File.dirname(path)).returns(true)
       @store.expects(:writelock).with(path, 0660).yields(file)
       file.expects(:print).with(yaml)
 
       @store.save(@request)
     end
 
     it "should create the indirection subdirectory if it does not exist" do
       yaml = @subject.to_yaml
       file = mock 'file'
       path = @store.send(:path, @subject.name)
       dir = File.dirname(path)
 
       FileTest.expects(:exist?).with(dir).returns(false)
       Dir.expects(:mkdir).with(dir)
 
       @store.expects(:writelock).yields(file)
       file.expects(:print).with(yaml)
 
       @store.save(@request)
     end
   end
 
   describe Puppet::Indirector::Yaml, " when retrieving YAML" do
     it "should read YAML in from disk using a read lock and convert it to Ruby objects" do
       path = @store.send(:path, @subject.name)
 
       yaml = @subject.to_yaml
       FileTest.expects(:exist?).with(path).returns(true)
 
       fh = mock 'filehandle'
       @store.expects(:readlock).with(path).yields fh
       fh.expects(:read).returns yaml
 
       @store.find(@request).instance_variable_get("@name").should == :me
     end
 
     it "should fail coherently when the stored YAML is invalid" do
       path = @store.send(:path, @subject.name)
       FileTest.expects(:exist?).with(path).returns(true)
 
       # Something that will fail in yaml
       yaml = "--- !ruby/object:Hash"
 
       fh = mock 'filehandle'
       @store.expects(:readlock).yields fh
       fh.expects(:read).returns yaml
 
       proc { @store.find(@request) }.should raise_error(Puppet::Error)
     end
   end
 
   describe Puppet::Indirector::Yaml, " when searching" do
     it "should return an array of fact instances with one instance for each file when globbing *" do
       @request = stub 'request', :key => "*", :instance => @subject
       @one = mock 'one'
       @two = mock 'two'
       @store.expects(:path).with(@request.key,'').returns :glob
       Dir.expects(:glob).with(:glob).returns(%w{one.yaml two.yaml})
       YAML.expects(:load_file).with("one.yaml").returns @one;
       YAML.expects(:load_file).with("two.yaml").returns @two;
       @store.search(@request).should == [@one, @two]
     end
 
     it "should return an array containing a single instance of fact when globbing 'one*'" do
       @request = stub 'request', :key => "one*", :instance => @subject
       @one = mock 'one'
       @store.expects(:path).with(@request.key,'').returns :glob
       Dir.expects(:glob).with(:glob).returns(%w{one.yaml})
       YAML.expects(:load_file).with("one.yaml").returns @one;
       @store.search(@request).should == [@one]
     end
 
     it "should return an empty array when the glob doesn't match anything" do
       @request = stub 'request', :key => "f*ilglobcanfail*", :instance => @subject
       @store.expects(:path).with(@request.key,'').returns :glob
       Dir.expects(:glob).with(:glob).returns []
       @store.search(@request).should == []
     end
   end
 end
diff --git a/spec/unit/network/authconfig_spec.rb b/spec/unit/network/authconfig_spec.rb
index 4367e25e6..9d69e99ac 100755
--- a/spec/unit/network/authconfig_spec.rb
+++ b/spec/unit/network/authconfig_spec.rb
@@ -1,292 +1,292 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/network/authconfig'
 
 describe Puppet::Network::AuthConfig do
   before do
     @rights = stubs 'rights'
     Puppet::Network::Rights.stubs(:new).returns(@rights)
     @rights.stubs(:each).returns([])
 
     FileTest.stubs(:exists?).returns(true)
     File.stubs(:stat).returns(stub('stat', :ctime => :now))
-    Time.stubs(:now).returns :now
+    Time.stubs(:now).returns Time.now
 
     @authconfig = Puppet::Network::AuthConfig.new("dummy", false)
   end
 
   describe "when initializing" do
     before :each do
       Puppet::Network::AuthConfig.any_instance.stubs(:read)
     end
 
     it "should use the authconfig default pathname if none provided" do
       Puppet.expects(:[]).with(:authconfig).returns("dummy")
 
       Puppet::Network::AuthConfig.new
     end
 
     it "should raise an error if no file is defined finally" do
       Puppet.stubs(:[]).with(:authconfig).returns(nil)
 
       lambda { Puppet::Network::AuthConfig.new }.should raise_error(Puppet::DevError)
     end
 
     it "should read and parse the file if parsenow is true" do
       Puppet::Network::AuthConfig.any_instance.expects(:read)
 
       Puppet::Network::AuthConfig.new("dummy", true)
     end
 
   end
 
   describe "when checking authorization" do
     before :each do
       @authconfig.stubs(:read)
       @call = stub 'call', :intern => "name"
       @handler = stub 'handler', :intern => "handler"
       @method = stub_everything 'method'
       @request = stub 'request', :call => @call, :handler => @handler, :method => @method, :name => "me", :ip => "1.2.3.4"
     end
 
     it "should attempt to read the authconfig file" do
       @rights.stubs(:include?)
 
       @authconfig.expects(:read)
 
       @authconfig.allowed?(@request)
     end
 
     it "should use a name right if it exists" do
       right = stub 'right'
 
       @rights.stubs(:include?).with("name").returns(true)
       @rights.stubs(:[]).with("name").returns(right)
 
       right.expects(:allowed?).with("me", "1.2.3.4")
 
       @authconfig.allowed?(@request)
     end
 
     it "should use a namespace right otherwise" do
       right = stub 'right'
 
       @rights.stubs(:include?).with("name").returns(false)
       @rights.stubs(:include?).with("handler").returns(true)
       @rights.stubs(:[]).with("handler").returns(right)
 
       right.expects(:allowed?).with("me", "1.2.3.4")
 
       @authconfig.allowed?(@request)
     end
 
     it "should return whatever the found rights returns" do
       right = stub 'right'
 
       @rights.stubs(:include?).with("name").returns(true)
       @rights.stubs(:[]).with("name").returns(right)
 
       right.stubs(:allowed?).with("me", "1.2.3.4").returns(:returned)
 
       @authconfig.allowed?(@request).should == :returned
     end
 
   end
 
   describe "when parsing authconfig file" do
     before :each do
       @fd = stub 'fd'
       File.stubs(:open).yields(@fd)
       @rights.stubs(:include?).returns(false)
       @rights.stubs(:[])
     end
 
     it "should skip comments" do
       @fd.stubs(:each).yields('  # comment')
 
       @rights.expects(:newright).never
 
       @authconfig.read
     end
 
     it "should increment line number even on commented lines" do
       @fd.stubs(:each).multiple_yields('  # comment','[puppetca]')
 
       @rights.expects(:newright).with('[puppetca]', 2, 'dummy')
 
       @authconfig.read
     end
 
     it "should skip blank lines" do
       @fd.stubs(:each).yields('  ')
 
       @rights.expects(:newright).never
 
       @authconfig.read
     end
 
     it "should increment line number even on blank lines" do
       @fd.stubs(:each).multiple_yields('  ','[puppetca]')
 
       @rights.expects(:newright).with('[puppetca]', 2, 'dummy')
 
       @authconfig.read
     end
 
     it "should throw an error if the current namespace right already exist" do
       @fd.stubs(:each).yields('[puppetca]')
 
       @rights.stubs(:include?).with("puppetca").returns(true)
 
       lambda { @authconfig.read }.should raise_error
     end
 
     it "should not throw an error if the current path right already exist" do
       @fd.stubs(:each).yields('path /hello')
 
       @rights.stubs(:newright).with("/hello",1, 'dummy')
       @rights.stubs(:include?).with("/hello").returns(true)
 
       lambda { @authconfig.read }.should_not raise_error
     end
 
     it "should create a new right for found namespaces" do
       @fd.stubs(:each).yields('[puppetca]')
 
       @rights.expects(:newright).with("[puppetca]", 1, 'dummy')
 
       @authconfig.read
     end
 
     it "should create a new right for each found namespace line" do
       @fd.stubs(:each).multiple_yields('[puppetca]', '[fileserver]')
 
       @rights.expects(:newright).with("[puppetca]", 1, 'dummy')
       @rights.expects(:newright).with("[fileserver]", 2, 'dummy')
 
       @authconfig.read
     end
 
     it "should create a new right for each found path line" do
       @fd.stubs(:each).multiple_yields('path /certificates')
 
       @rights.expects(:newright).with("/certificates", 1, 'dummy')
 
       @authconfig.read
     end
 
     it "should create a new right for each found regex line" do
       @fd.stubs(:each).multiple_yields('path ~ .rb$')
 
       @rights.expects(:newright).with("~ .rb$", 1, 'dummy')
 
       @authconfig.read
     end
 
     it "should create an allow ACE on each subsequent allow" do
       acl = stub 'acl', :info
 
       @fd.stubs(:each).multiple_yields('[puppetca]', 'allow 127.0.0.1')
       @rights.stubs(:newright).with("[puppetca]", 1, 'dummy').returns(acl)
 
       acl.expects(:allow).with('127.0.0.1')
 
       @authconfig.read
     end
 
     it "should create a deny ACE on each subsequent deny" do
       acl = stub 'acl', :info
 
       @fd.stubs(:each).multiple_yields('[puppetca]', 'deny 127.0.0.1')
       @rights.stubs(:newright).with("[puppetca]", 1, 'dummy').returns(acl)
 
       acl.expects(:deny).with('127.0.0.1')
 
       @authconfig.read
     end
 
     it "should inform the current ACL if we get the 'method' directive" do
       acl = stub 'acl', :info
       acl.stubs(:acl_type).returns(:regex)
 
       @fd.stubs(:each).multiple_yields('path /certificates', 'method search,find')
       @rights.stubs(:newright).with("/certificates", 1, 'dummy').returns(acl)
 
       acl.expects(:restrict_method).with('search')
       acl.expects(:restrict_method).with('find')
 
       @authconfig.read
     end
 
     it "should raise an error if the 'method' directive is used in a right different than a path/regex one" do
       acl = stub 'acl', :info
       acl.stubs(:acl_type).returns(:regex)
 
       @fd.stubs(:each).multiple_yields('[puppetca]', 'method search,find')
       @rights.stubs(:newright).with("puppetca", 1, 'dummy').returns(acl)
 
       lambda { @authconfig.read }.should raise_error
     end
 
     it "should inform the current ACL if we get the 'environment' directive" do
       acl = stub 'acl', :info
       acl.stubs(:acl_type).returns(:regex)
 
       @fd.stubs(:each).multiple_yields('path /certificates', 'environment production,development')
       @rights.stubs(:newright).with("/certificates", 1, 'dummy').returns(acl)
 
       acl.expects(:restrict_environment).with('production')
       acl.expects(:restrict_environment).with('development')
 
       @authconfig.read
     end
 
     it "should raise an error if the 'environment' directive is used in a right different than a path/regex one" do
       acl = stub 'acl', :info
       acl.stubs(:acl_type).returns(:regex)
 
       @fd.stubs(:each).multiple_yields('[puppetca]', 'environment env')
       @rights.stubs(:newright).with("puppetca", 1, 'dummy').returns(acl)
 
       lambda { @authconfig.read }.should raise_error
     end
 
     it "should inform the current ACL if we get the 'auth' directive" do
       acl = stub 'acl', :info
       acl.stubs(:acl_type).returns(:regex)
 
       @fd.stubs(:each).multiple_yields('path /certificates', 'auth yes')
       @rights.stubs(:newright).with("/certificates", 1, 'dummy').returns(acl)
 
       acl.expects(:restrict_authenticated).with('yes')
 
       @authconfig.read
     end
 
     it "should also allow the longest 'authenticated' directive" do
       acl = stub 'acl', :info
       acl.stubs(:acl_type).returns(:regex)
 
       @fd.stubs(:each).multiple_yields('path /certificates', 'authenticated yes')
       @rights.stubs(:newright).with("/certificates", 1, 'dummy').returns(acl)
 
       acl.expects(:restrict_authenticated).with('yes')
 
       @authconfig.read
     end
 
     it "should raise an error if the 'auth' directive is used in a right different than a path/regex one" do
       acl = stub 'acl', :info
       acl.stubs(:acl_type).returns(:regex)
 
       @fd.stubs(:each).multiple_yields('[puppetca]', 'auth yes')
       @rights.stubs(:newright).with("puppetca", 1, 'dummy').returns(acl)
 
       lambda { @authconfig.read }.should raise_error
     end
 
   end
 
 end
diff --git a/spec/unit/network/rest_authconfig_spec.rb b/spec/unit/network/rest_authconfig_spec.rb
index 270d1d094..e0bcb5af0 100755
--- a/spec/unit/network/rest_authconfig_spec.rb
+++ b/spec/unit/network/rest_authconfig_spec.rb
@@ -1,139 +1,139 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/network/rest_authconfig'
 
 describe Puppet::Network::RestAuthConfig do
 
   DEFAULT_ACL = [
     { :acl => "~ ^\/catalog\/([^\/]+)$", :method => :find, :allow => '$1', :authenticated => true },
     # this one will allow all file access, and thus delegate
     # to fileserver.conf
     { :acl => "/file" },
     { :acl => "/certificate_revocation_list/ca", :method => :find, :authenticated => true },
     { :acl => "/report", :method => :save, :authenticated => true },
     { :acl => "/certificate/ca", :method => :find, :authenticated => false },
     { :acl => "/certificate/", :method => :find, :authenticated => false },
     { :acl => "/certificate_request", :method => [:find, :save], :authenticated => false },
     { :acl => "/status", :method => [:find], :authenticated => true },
   ]
 
   before :each do
     FileTest.stubs(:exists?).returns(true)
     File.stubs(:stat).returns(stub('stat', :ctime => :now))
-    Time.stubs(:now).returns :now
+    Time.stubs(:now).returns Time.now
 
     @authconfig = Puppet::Network::RestAuthConfig.new("dummy", false)
     @authconfig.stubs(:read)
 
     @acl = stub_everything 'rights'
     @authconfig.rights = @acl
   end
 
   it "should use the puppet default rest authorization file" do
     Puppet.expects(:[]).with(:rest_authconfig).returns("dummy")
 
     Puppet::Network::RestAuthConfig.new(nil, false)
   end
 
   it "should ask for authorization to the ACL subsystem" do
     params = {:ip => "127.0.0.1", :node => "me", :environment => :env, :authenticated => true}
     @acl.expects(:is_request_forbidden_and_why?).with("path", :save, "to/resource", params).returns(nil)
 
     @authconfig.allowed?("path", :save, "to/resource", params)
   end
 
   describe "when defining an acl with mk_acl" do
     it "should create a new right for each default acl" do
       @acl.expects(:newright).with(:path)
       @authconfig.mk_acl(:acl => :path)
     end
 
     it "should allow everyone for each default right" do
       @acl.expects(:allow).with(:path, "*")
       @authconfig.mk_acl(:acl => :path)
     end
 
     it "should restrict the ACL to a method" do
       @acl.expects(:restrict_method).with(:path, :method)
       @authconfig.mk_acl(:acl => :path, :method => :method)
     end
 
     it "should restrict the ACL to a specific authentication state" do
       @acl.expects(:restrict_authenticated).with(:path, :authentication)
       @authconfig.mk_acl(:acl => :path, :authenticated => :authentication)
     end
   end
 
   describe "when parsing the configuration file" do
     it "should check for missing ACL after reading the authconfig file" do
       File.stubs(:open)
 
       @authconfig.expects(:insert_default_acl)
 
       @authconfig.parse
     end
   end
 
   DEFAULT_ACL.each do |acl|
     it "should insert #{acl[:acl]} if not present" do
       @authconfig.rights.stubs(:[]).returns(true)
       @authconfig.rights.stubs(:[]).with(acl[:acl]).returns(nil)
 
       @authconfig.expects(:mk_acl).with { |h| h[:acl] == acl[:acl] }
 
       @authconfig.insert_default_acl
     end
 
     it "should not insert #{acl[:acl]} if present" do
       @authconfig.rights.stubs(:[]).returns(true)
       @authconfig.rights.stubs(:[]).with(acl).returns(true)
 
       @authconfig.expects(:mk_acl).never
 
       @authconfig.insert_default_acl
     end
   end
 
   it "should create default ACL entries if no file have been read" do
     Puppet::Network::RestAuthConfig.any_instance.stubs(:exists?).returns(false)
 
     Puppet::Network::RestAuthConfig.any_instance.expects(:insert_default_acl)
 
     Puppet::Network::RestAuthConfig.main
   end
 
   describe "when adding default ACLs" do
 
     DEFAULT_ACL.each do |acl|
       it "should create a default right for #{acl[:acl]}" do
         @authconfig.stubs(:mk_acl)
         @authconfig.expects(:mk_acl).with(acl)
         @authconfig.insert_default_acl
       end
     end
 
     it "should log at info loglevel" do
       Puppet.expects(:info).at_least_once
       @authconfig.insert_default_acl
     end
 
     it "should create a last catch-all deny all rule" do
       @authconfig.stubs(:mk_acl)
       @acl.expects(:newright).with("/")
       @authconfig.insert_default_acl
     end
 
     it "should create a last catch-all deny all rule for any authenticated request state" do
       @authconfig.stubs(:mk_acl)
       @acl.stubs(:newright).with("/")
 
       @acl.expects(:restrict_authenticated).with("/", :any)
 
       @authconfig.insert_default_acl
     end
 
   end
 
 end
diff --git a/spec/unit/parser/ast/casestatement_spec.rb b/spec/unit/parser/ast/casestatement_spec.rb
index a77c04c43..bce3ad801 100755
--- a/spec/unit/parser/ast/casestatement_spec.rb
+++ b/spec/unit/parser/ast/casestatement_spec.rb
@@ -1,161 +1,165 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe Puppet::Parser::AST::CaseStatement do
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   describe "when evaluating" do
 
     before :each do
       @test = stub 'test'
       @test.stubs(:safeevaluate).with(@scope).returns("value")
 
-      @option1 = stub 'option1', :eachopt => nil, :default? => false
-      @option2 = stub 'option2', :eachopt => nil, :default? => false
+      @option1 = Puppet::Parser::AST::CaseOpt.new({})
+      @option1.stubs(:eachopt)
+      @option1.stubs(:default?).returns false
+      @option2 = Puppet::Parser::AST::CaseOpt.new({})
+      @option2.stubs(:eachopt)
+      @option2.stubs(:default?).returns false
 
-      @options = stub 'options'
-      @options.stubs(:each).multiple_yields(@option1, @option2)
+      @options = Puppet::Parser::AST::ASTArray.new(:children => [@option1, @option2])
 
       @casestmt = Puppet::Parser::AST::CaseStatement.new :test => @test, :options => @options
     end
 
     it "should evaluate test" do
       @test.expects(:safeevaluate).with(@scope)
 
       @casestmt.evaluate(@scope)
     end
 
     it "should scan each option" do
-      @options.expects(:each).multiple_yields(@option1, @option2)
-
       @casestmt.evaluate(@scope)
     end
 
     describe "when scanning options" do
       before :each do
         @opval1 = stub_everything 'opval1'
         @option1.stubs(:eachopt).yields(@opval1)
 
         @opval2 = stub_everything 'opval2'
         @option2.stubs(:eachopt).yields(@opval2)
       end
 
       it "should evaluate each sub-option" do
         @option1.expects(:eachopt)
         @option2.expects(:eachopt)
 
         @casestmt.evaluate(@scope)
       end
 
       it "should evaluate first matching option" do
         @opval2.stubs(:evaluate_match).with { |*arg| arg[0] == "value" }.returns(true)
         @option2.expects(:safeevaluate).with(@scope)
 
         @casestmt.evaluate(@scope)
       end
 
       it "should return the first matching evaluated option" do
         @opval2.stubs(:evaluate_match).with { |*arg| arg[0] == "value" }.returns(true)
         @option2.stubs(:safeevaluate).with(@scope).returns(:result)
 
         @casestmt.evaluate(@scope).should == :result
       end
 
       it "should evaluate the default option if none matched" do
         @option1.stubs(:default?).returns(true)
         @option1.expects(:safeevaluate).with(@scope)
 
         @casestmt.evaluate(@scope)
       end
 
       it "should return the default evaluated option if none matched" do
         @option1.stubs(:default?).returns(true)
         @option1.stubs(:safeevaluate).with(@scope).returns(:result)
 
         @casestmt.evaluate(@scope).should == :result
       end
 
       it "should return nil if nothing matched" do
         @casestmt.evaluate(@scope).should be_nil
       end
 
       it "should match and set scope ephemeral variables" do
         @opval1.expects(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }
 
         @casestmt.evaluate(@scope)
       end
 
       it "should evaluate this regex option if it matches" do
         @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
 
         @option1.expects(:safeevaluate).with(@scope)
 
         @casestmt.evaluate(@scope)
       end
 
       it "should return this evaluated regex option if it matches" do
         @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
         @option1.stubs(:safeevaluate).with(@scope).returns(:result)
 
         @casestmt.evaluate(@scope).should == :result
       end
 
       it "should unset scope ephemeral variables after option evaluation" do
         @scope.stubs(:ephemeral_level).returns(:level)
         @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
         @option1.stubs(:safeevaluate).with(@scope).returns(:result)
 
         @scope.expects(:unset_ephemeral_var).with(:level)
 
         @casestmt.evaluate(@scope)
       end
 
       it "should not leak ephemeral variables even if evaluation fails" do
         @scope.stubs(:ephemeral_level).returns(:level)
         @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
         @option1.stubs(:safeevaluate).with(@scope).raises
 
         @scope.expects(:unset_ephemeral_var).with(:level)
 
         lambda { @casestmt.evaluate(@scope) }.should raise_error
       end
     end
 
   end
 
   it "should match if any of the provided options evaluate as true" do
     ast = nil
     AST = Puppet::Parser::AST
 
     tests = {
       "one" => %w{a b c},
       "two" => %w{e f g}
     }
     options = tests.collect do |result, values|
       values = values.collect { |v| AST::Leaf.new :value => v }
 
-            AST::CaseOpt.new(
-        :value => AST::ASTArray.new(:children => values),
-        
-        :statements => AST::Leaf.new(:value => result))
+      AST::CaseOpt.new(
+        :value      => AST::ASTArray.new(:children => values),
+        :statements => AST::Leaf.new(:value => result)
+      )
     end
-    options << AST::CaseOpt.new(:value => AST::Default.new(:value => "default"), :statements => AST::Leaf.new(:value => "default"))
+    options << AST::CaseOpt.new(
+      :value      => AST::Default.new(:value => "default"), 
+      :statements => AST::Leaf.new(:value => "default")
+    )
 
     ast = nil
     param = AST::Variable.new(:value => "testparam")
     ast = AST::CaseStatement.new(:test => param, :options => options)
 
     tests.each do |should, values|
       values.each do |value|
         @scope = Puppet::Parser::Scope.new
         @scope.setvar("testparam", value)
         result = ast.evaluate(@scope)
 
         result.should == should
       end
     end
   end
 end