diff --git a/lib/puppet/graph/simple_graph.rb b/lib/puppet/graph/simple_graph.rb
index f964fee7f..f230ffb18 100644
--- a/lib/puppet/graph/simple_graph.rb
+++ b/lib/puppet/graph/simple_graph.rb
@@ -1,559 +1,559 @@
 require 'puppet/external/dot'
 require 'puppet/relationship'
 require 'set'
 
 # A hopefully-faster graph class to replace the use of GRATR.
 class Puppet::Graph::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.
   #
   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
             s[:scc] << this_scc
           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
 
     # To provide consistent results to the user, given that a hash is never
     # assured to return the same order, and given our graph processing is
     # based on hash tables, we need to sort the cycles internally, as well as
     # the set of cycles.
     #
     # Given we are in a failure state here, any extra cost is more or less
     # irrelevant compared to the cost of a fix - which is on a human
     # time-scale.
     state[:scc].select do |component|
       multi_vertex_component?(component) || single_vertex_referring_to_self?(component)
     end.map do |component|
       component.sort
     end.sort
   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.sort
   end
 
   def report_cycles_in_graph
     cycles = find_cycles_in_graph
     n = cycles.length           # where is "pluralize"? --daniel 2011-01-22
     return if n == 0
     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
 
   # 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
 
   # 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 direct_dependents_of(v)
     (@out_from[v] || {}).keys
   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
 
   def direct_dependencies_of(v)
     (@in_to[v] || {}).keys
   end
 
   # Return an array of the edge-sets between a series of n+1 vertices (f=v0,v1,v2...t=vn)
   #   connecting the two given verticies.  The ith edge set is an array containing all the
   #   edges between v(i) and v(i+1); these are (by definition) never empty.
   #
   #     * if f == t, the list is empty
   #     * if they are adjacent the result is an array consisting of
   #       a single array (the edges from f to t)
   #     * and so on by induction on a vertex m between them
   #     * if there is no path from f to t, the result is nil
   #
   # This implementation is not particularly efficient; it's used in testing where clarity
   #   is more important than last-mile efficiency.
   #
   def path_between(f,t)
     if f==t
       []
     elsif direct_dependents_of(f).include?(t)
       [edges_between(f,t)]
     elsif dependents(f).include?(t)
       m = (dependents(f) & direct_dependencies_of(t)).first
       path_between(f,m) + path_between(m,t)
     else
       nil
     end
   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.ref
       params = {'name'     => '"'+name+'"',
         'fontsize' => fontsize,
         'label'    => name}
       v_label = v.ref
       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.ref + '"',
         'to'       => '"'+ e.target.ref + '"',
         'fontsize' => fontsize }
       e_label = e.ref
       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
 
   # 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
+  # instance_variable_get is used by YAML.dump 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::Graph::SimpleGraph::VertexWrapper.new(vertex, adjacencies)
         end
         result
       end
     else
       super(v)
     end
   end
 
   def to_yaml_properties
     (super + [:@vertices, :@edges] -
      [:@in_to, :@out_from, :@upstream_from, :@downstream_from]).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
 
   def multi_vertex_component?(component)
     component.length > 1
   end
   private :multi_vertex_component?
 
   def single_vertex_referring_to_self?(component)
     if component.length == 1
       vertex = component[0]
       adjacent(vertex).include?(vertex)
     else
       false
     end
   end
   private :single_vertex_referring_to_self?
 end
diff --git a/lib/puppet/indirector/request.rb b/lib/puppet/indirector/request.rb
index 5787106f8..ee243060b 100644
--- a/lib/puppet/indirector/request.rb
+++ b/lib/puppet/indirector/request.rb
@@ -1,241 +1,259 @@
 require 'cgi'
 require 'uri'
 require 'puppet/indirector'
 require 'puppet/network/resolver'
+require 'puppet/util/psych_support'
 
 # This class encapsulates all of the information you need to make an
 # Indirection call, and as a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
+  include Puppet::Util::PsychSupport
 
   attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
 
   attr_accessor :server, :port, :uri, :protocol
 
   attr_reader :indirection_name
 
   # trusted_information is specifically left out because we can't serialize it
   # and keep it "trusted"
   OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
 
   # Is this an authenticated request?
   def authenticated?
     # Double negative, so we just get true or false
     ! ! authenticated
   end
 
   def environment
     # If environment has not been set directly, we should use the application's
     # current environment
     @environment ||= Puppet.lookup(:current_environment)
   end
 
   def environment=(env)
     @environment =
     if env.is_a?(Puppet::Node::Environment)
       env
     elsif (current_environment = Puppet.lookup(:current_environment)).name == env
       current_environment
     else
       Puppet.lookup(:environments).get!(env)
     end
   end
 
   def escaped_key
     URI.escape(key)
   end
 
   # LAK:NOTE This is a messy interface to the cache, and it's only
   # used by the Configurer class.  I decided it was better to implement
   # it now and refactor later, when we have a better design, than
   # to spend another month coming up with a design now that might
   # not be any better.
   def ignore_cache?
     ignore_cache
   end
 
   def ignore_terminus?
     ignore_terminus
   end
 
   def initialize(indirection_name, method, key, instance, options = {})
     @instance = instance
     options ||= {}
 
     self.indirection_name = indirection_name
     self.method = method
 
     options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
 
     set_attributes(options)
 
     @options = options
 
     if key
       # If the request key is a URI, then we need to treat it specially,
       # because it rewrites the key.  We could otherwise strip server/port/etc
       # info out in the REST class, but it seemed bad design for the REST
       # class to rewrite the key.
 
       if key.to_s =~ /^\w+:\// and not Puppet::Util.absolute_path?(key.to_s) # it's a URI
         set_uri_key(key)
       else
         @key = key
       end
     end
 
     @key = @instance.name if ! @key and @instance
   end
 
   # Look up the indirection based on the name provided.
   def indirection
     Puppet::Indirector::Indirection.instance(indirection_name)
   end
 
   def indirection_name=(name)
     @indirection_name = name.to_sym
   end
 
   def model
     raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless i = indirection
     i.model
   end
 
   # Are we trying to interact with multiple resources, or just one?
   def plural?
     method == :search
   end
 
   # Create the query string, if options are present.
   def query_string
     return "" if options.nil? || options.empty?
     "?" + encode_params(expand_into_parameters(options.to_a))
   end
 
   def expand_into_parameters(data)
     data.inject([]) do |params, key_value|
       key, value = key_value
 
       expanded_value = case value
                        when Array
                          value.collect { |val| [key, val] }
                        else
                          [key_value]
                        end
 
       params.concat(expand_primitive_types_into_parameters(expanded_value))
     end
   end
 
   def expand_primitive_types_into_parameters(data)
     data.inject([]) do |params, key_value|
       key, value = key_value
       case value
       when nil
         params
       when true, false, String, Symbol, Fixnum, Bignum, Float
         params << [key, value]
       else
         raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
       end
     end
   end
 
   def encode_params(params)
     params.collect do |key, value|
       "#{key}=#{CGI.escape(value.to_s)}"
     end.join("&")
   end
 
+  def initialize_from_hash(hash)
+    @indirection_name = hash['indirection_name'].to_sym
+    @method = hash['method'].to_sym
+    @key = hash['key']
+    @instance = hash['instance']
+    @options = hash['options']
+  end
+
+  def to_data_hash
+    { 'indirection_name' => @indirection_name.to_s,
+      'method' => @method.to_s,
+      'key' => @key,
+      'instance' => @instance,
+      'options' => @options }
+  end
+
   def to_hash
     result = options.dup
 
     OPTION_ATTRIBUTES.each do |attribute|
       if value = send(attribute)
         result[attribute] = value
       end
     end
     result
   end
 
   def to_s
     return(uri ? uri : "/#{indirection_name}/#{key}")
   end
 
   def do_request(srv_service=:puppet, default_server=Puppet.settings[:server], default_port=Puppet.settings[:masterport], &block)
     # We were given a specific server to use, so just use that one.
     # This happens if someone does something like specifying a file
     # source using a puppet:// URI with a specific server.
     return yield(self) if !self.server.nil?
 
     if Puppet.settings[:use_srv_records]
       Puppet::Network::Resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
         begin
           self.server = srv_server
           self.port   = srv_port
           return yield(self)
         rescue SystemCallError => e
           Puppet.warning "Error connecting to #{srv_server}:#{srv_port}: #{e.message}"
         end
       end
     end
 
     # ... Fall back onto the default server.
     Puppet.debug "No more servers left, falling back to #{default_server}:#{default_port}" if Puppet.settings[:use_srv_records]
     self.server = default_server
     self.port   = default_port
     return yield(self)
   end
 
   def remote?
     self.node or self.ip
   end
 
   private
 
   def set_attributes(options)
     OPTION_ATTRIBUTES.each do |attribute|
       if options.include?(attribute.to_sym)
         send(attribute.to_s + "=", options[attribute])
         options.delete(attribute)
       end
     end
   end
 
   # Parse the key as a URI, setting attributes appropriately.
   def set_uri_key(key)
     @uri = key
     begin
       uri = URI.parse(URI.escape(key))
     rescue => detail
       raise ArgumentError, "Could not understand URL #{key}: #{detail}", detail.backtrace
     end
 
     # Just short-circuit these to full paths
     if uri.scheme == "file"
       @key = Puppet::Util.uri_to_path(uri)
       return
     end
 
     @server = uri.host if uri.host
 
     # If the URI class can look up the scheme, it will provide a port,
     # otherwise it will default to '0'.
     if uri.port.to_i == 0 and uri.scheme == "puppet"
       @port = Puppet.settings[:masterport].to_i
     else
       @port = uri.port.to_i
     end
 
     @protocol = uri.scheme
 
     if uri.scheme == 'puppet'
       @key = URI.unescape(uri.path.sub(/^\//, ''))
       return
     end
 
     env, indirector, @key = URI.unescape(uri.path.sub(/^\//, '')).split('/',3)
     @key ||= ''
     self.environment = env unless env == ''
   end
 end
diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb
index f1cfb6848..1f26eef99 100644
--- a/lib/puppet/node/environment.rb
+++ b/lib/puppet/node/environment.rb
@@ -1,607 +1,602 @@
 require 'puppet/util'
 require 'puppet/util/cacher'
 require 'monitor'
 require 'puppet/parser/parser_factory'
 
 # Just define it, so this class has fewer load dependencies.
 class Puppet::Node
 end
 
 # Puppet::Node::Environment acts as a container for all configuration
 # that is expected to vary between environments.
 #
 # ## The root environment
 #
 # In addition to normal environments that are defined by the user,there is a
 # special 'root' environment. It is defined as an instance variable on the
 # Puppet::Node::Environment metaclass. The environment name is `*root*` and can
 # be accessed by looking up the `:root_environment` using {Puppet.lookup}.
 #
 # The primary purpose of the root environment is to contain parser functions
 # that are not bound to a specific environment. The main case for this is for
 # logging functions. Logging functions are attached to the 'root' environment
 # when {Puppet::Parser::Functions.reset} is called.
 class Puppet::Node::Environment
   include Puppet::Util::Cacher
 
   NO_MANIFEST = :no_manifest
 
   # @api private
   def self.seen
     @seen ||= {}
   end
 
   # Create a new environment with the given name, or return an existing one
   #
   # The environment class memoizes instances so that attempts to instantiate an
   # environment with the same name with an existing environment will return the
   # existing environment.
   #
   # @overload self.new(environment)
   #   @param environment [Puppet::Node::Environment]
   #   @return [Puppet::Node::Environment] the environment passed as the param,
   #     this is implemented so that a calling class can use strings or
   #     environments interchangeably.
   #
   # @overload self.new(string)
   #   @param string [String, Symbol]
   #   @return [Puppet::Node::Environment] An existing environment if it exists,
   #     else a new environment with that name
   #
   # @overload self.new()
   #   @return [Puppet::Node::Environment] The environment as set by
   #     Puppet.settings[:environment]
   #
   # @api public
   def self.new(name = nil)
     return name if name.is_a?(self)
     name ||= Puppet.settings.value(:environment)
 
     raise ArgumentError, "Environment name must be specified" unless name
 
     symbol = name.to_sym
 
     return seen[symbol] if seen[symbol]
 
     obj = self.create(symbol,
              split_path(Puppet.settings.value(:modulepath, symbol)),
              Puppet.settings.value(:manifest, symbol),
              Puppet.settings.value(:config_version, symbol))
     seen[symbol] = obj
   end
 
   # Create a new environment with the given name
   #
   # @param name [Symbol] the name of the
   # @param modulepath [Array<String>] the list of paths from which to load modules
   # @param manifest [String] the path to the manifest for the environment or
   # the constant Puppet::Node::Environment::NO_MANIFEST if there is none.
   # @param config_version [String] path to a script whose output will be added
   #   to report logs (optional)
   # @return [Puppet::Node::Environment]
   #
   # @api public
   def self.create(name, modulepath, manifest = NO_MANIFEST, config_version = nil)
     obj = self.allocate
     obj.send(:initialize,
              name,
              expand_dirs(extralibs() + modulepath),
              manifest == NO_MANIFEST ? manifest : File.expand_path(manifest),
              config_version)
     obj
   end
 
   # A "reference" to a remote environment. The created environment instance
   # isn't expected to exist on the local system, but is instead a reference to
   # environment information on a remote system. For instance when a catalog is
   # being applied, this will be used on the agent.
   #
   # @note This does not provide access to the information of the remote
   # environment's modules, manifest, or anything else. It is simply a value
   # object to pass around and use as an environment.
   #
   # @param name [Symbol] The name of the remote environment
   #
   def self.remote(name)
     create(name, [], NO_MANIFEST)
   end
 
   # Instantiate a new environment
   #
   # @note {Puppet::Node::Environment.new} is overridden to return memoized
   #   objects, so this will not be invoked with the normal Ruby initialization
   #   semantics.
   #
   # @param name [Symbol] The environment name
   def initialize(name, modulepath, manifest, config_version)
     @name = name
     @modulepath = modulepath
     @manifest = manifest
     @config_version = config_version
     # set watching to true for legacy environments - the directory based environment loaders will set this to
     # false for directory based environments after the environment has been created.
     @watching = true
   end
 
   # Returns if files are being watched or not.
   # @api private
   #
   def watching?
     @watching
   end
 
   # Turns watching of files on or off
   # @param flag [TrueClass, FalseClass] if files should be watched or not
   # @ api private
   def watching=(flag)
     @watching = flag
   end
 
   # Creates a new Puppet::Node::Environment instance, overriding any of the passed
   # parameters.
   #
   # @param env_params [Hash<{Symbol => String,Array<String>}>] new environment
   #   parameters (:modulepath, :manifest, :config_version)
   # @return [Puppet::Node::Environment]
   def override_with(env_params)
     return self.class.create(name,
                       env_params[:modulepath] || modulepath,
                       env_params[:manifest] || manifest,
                       env_params[:config_version] || config_version)
   end
 
   # Creates a new Puppet::Node::Environment instance, overriding manfiest
   # modulepath, or :config_version from the passed settings if they were
   # originally set from the commandline, or returns self if there is nothing to
   # override.
   #
   # @param settings [Puppet::Settings] an initialized puppet settings instance
   # @return [Puppet::Node::Environment] new overridden environment or self if
   #   there are no commandline changes from settings.
   def override_from_commandline(settings)
     overrides = {}
 
     if settings.set_by_cli?(:modulepath)
       overrides[:modulepath] = self.class.split_path(settings.value(:modulepath))
     end
 
     if settings.set_by_cli?(:config_version)
       overrides[:config_version] = settings.value(:config_version)
     end
 
     if settings.set_by_cli?(:manifest) ||
       (settings.set_by_cli?(:manifestdir) && settings.value(:manifest).start_with?(settings.value(:manifestdir)))
       overrides[:manifest] = settings.value(:manifest)
     end
 
     overrides.empty? ?
       self :
       self.override_with(overrides)
   end
 
   # Retrieve the environment for the current process.
   #
   # @note This should only used when a catalog is being compiled.
   #
   # @api private
   #
   # @return [Puppet::Node::Environment] the currently set environment if one
   #   has been explicitly set, else it will return the '*root*' environment
   def self.current
     Puppet.deprecation_warning("Puppet::Node::Environment.current has been replaced by Puppet.lookup(:current_environment), see http://links.puppetlabs.com/current-env-deprecation")
     Puppet.lookup(:current_environment)
   end
 
   # @param [String] name Environment name to check for valid syntax.
   # @return [Boolean] true if name is valid
   # @api public
   def self.valid_name?(name)
     !!name.match(/\A\w+\Z/)
   end
 
   # Clear all memoized environments and the 'current' environment
   #
   # @api private
   def self.clear
     seen.clear
   end
 
   # @!attribute [r] name
   #   @api public
   #   @return [Symbol] the human readable environment name that serves as the
   #     environment identifier
   attr_reader :name
 
   # @api public
   # @return [Array<String>] All directories present on disk in the modulepath
   def modulepath
     @modulepath.find_all do |p|
       Puppet::FileSystem.directory?(p)
     end
   end
 
   # @api public
   # @return [Array<String>] All directories in the modulepath (even if they are not present on disk)
   def full_modulepath
     @modulepath
   end
 
   # @!attribute [r] manifest
   #   @api public
   #   @return [String] path to the manifest file or directory.
   attr_reader :manifest
 
   # @!attribute [r] config_version
   #   @api public
   #   @return [String] path to a script whose output will be added to report logs
   #     (optional)
   attr_reader :config_version
 
   # Checks to make sure that this environment did not have a manifest set in
   # its original environment.conf if Puppet is configured with
   # +disable_per_environment_manifest+ set true.  If it did, the environment's
   # modules may not function as intended by the original authors, and we may
   # seek to halt a puppet compilation for a node in this environment.
   #
   # The only exception to this would be if the environment.conf manifest is an exact,
   # uninterpolated match for the current +default_manifest+ setting.
   #
   # @return [Boolean] true if using directory environments, and
   #   Puppet[:disable_per_environment_manifest] is true, and this environment's
   #   original environment.conf had a manifest setting that is not the
   #   Puppet[:default_manifest].
   # @api private 
   def conflicting_manifest_settings?
     return false if Puppet[:environmentpath].empty? || !Puppet[:disable_per_environment_manifest]
     environment_conf = Puppet.lookup(:environments).get_conf(name)
     original_manifest = environment_conf.raw_setting(:manifest)
     !original_manifest.nil? && !original_manifest.empty? && original_manifest != Puppet[:default_manifest]
   end
 
   # Checks the environment and settings for any conflicts
   # @return [Array<String>] an array of validation errors
   # @api public
   def validation_errors
     errors = []
     if conflicting_manifest_settings?
       errors << "The 'disable_per_environment_manifest' setting is true, and the '#{name}' environment has an environment.conf manifest that conflicts with the 'default_manifest' setting."
     end
     errors
   end
 
   # Return an environment-specific Puppet setting.
   #
   # @api public
   #
   # @param param [String, Symbol] The environment setting to look up
   # @return [Object] The resolved setting value
   def [](param)
     Puppet.settings.value(param, self.name)
   end
 
   # @api public
   # @return [Puppet::Resource::TypeCollection] The current global TypeCollection
   def known_resource_types
     if @known_resource_types.nil?
       @known_resource_types = Puppet::Resource::TypeCollection.new(self)
       @known_resource_types.import_ast(perform_initial_import(), '')
     end
     @known_resource_types
   end
 
   # Yields each modules' plugin directory if the plugin directory (modulename/lib)
   # is present on the filesystem.
   #
   # @yield [String] Yields the plugin directory from each module to the block.
   # @api public
   def each_plugin_directory(&block)
     modules.map(&:plugin_directory).each do |lib|
       lib = Puppet::Util::Autoload.cleanpath(lib)
       yield lib if File.directory?(lib)
     end
   end
 
   # Locate a module instance by the module name alone.
   #
   # @api public
   #
   # @param name [String] The module name
   # @return [Puppet::Module, nil] The module if found, else nil
   def module(name)
     modules.find {|mod| mod.name == name}
   end
 
   # Locate a module instance by the full forge name (EG authorname/module)
   #
   # @api public
   #
   # @param forge_name [String] The module name
   # @return [Puppet::Module, nil] The module if found, else nil
   def module_by_forge_name(forge_name)
     author, modname = forge_name.split('/')
     found_mod = self.module(modname)
     found_mod and found_mod.forge_name == forge_name ?
       found_mod :
       nil
   end
 
   # @!attribute [r] modules
   #   Return all modules for this environment in the order they appear in the
   #   modulepath.
   #   @note If multiple modules with the same name are present they will
   #     both be added, but methods like {#module} and {#module_by_forge_name}
   #     will return the first matching entry in this list.
   #   @note This value is cached so that the filesystem doesn't have to be
   #     re-enumerated every time this method is invoked, since that
   #     enumeration could be a costly operation and this method is called
   #     frequently. The cache expiry is determined by `Puppet[:filetimeout]`.
   #   @see Puppet::Util::Cacher.cached_attr
   #   @api public
   #   @return [Array<Puppet::Module>] All modules for this environment
   cached_attr(:modules, Puppet[:filetimeout]) do
     module_references = []
     seen_modules = {}
     modulepath.each do |path|
       Dir.entries(path).each do |name|
         next if name == "." || name == ".."
         warn_about_mistaken_path(path, name)
         if not seen_modules[name]
           module_references << {:name => name, :path => File.join(path, name)}
           seen_modules[name] = true
         end
       end
     end
 
     module_references.collect do |reference|
       begin
         Puppet::Module.new(reference[:name], reference[:path], self)
       rescue Puppet::Module::Error => e
         Puppet.log_exception(e)
         nil
       end
     end.compact
   end
 
   # Generate a warning if the given directory in a module path entry is named `lib`.
   #
   # @api private
   #
   # @param path [String] The module directory containing the given directory
   # @param name [String] The directory name
   def warn_about_mistaken_path(path, name)
     if name == "lib"
       Puppet.debug("Warning: Found directory named 'lib' in module path ('#{path}/lib'); unless " +
           "you are expecting to load a module named 'lib', your module path may be set " +
           "incorrectly.")
     end
   end
 
   # Modules broken out by directory in the modulepath
   #
   # @note This method _changes_ the current working directory while enumerating
   #   the modules. This seems rather dangerous.
   #
   # @api public
   #
   # @return [Hash<String, Array<Puppet::Module>>] A hash whose keys are file
   #   paths, and whose values is an array of Puppet Modules for that path
   def modules_by_path
     modules_by_path = {}
     modulepath.each do |path|
       Dir.chdir(path) do
         module_names = Dir.glob('*').select do |d|
           FileTest.directory?(d) && (File.basename(d) =~ /\A\w+(-\w+)*\Z/)
         end
         modules_by_path[path] = module_names.sort.map do |name|
           Puppet::Module.new(name, File.join(path, name), self)
         end
       end
     end
     modules_by_path
   end
 
   # All module requirements for all modules in the environment modulepath
   #
   # @api public
   #
   # @comment This has nothing to do with an environment. It seems like it was
   #   stuffed into the first convenient class that vaguely involved modules.
   #
   # @example
   #   environment.module_requirements
   #   # => {
   #   #   'username/amodule' => [
   #   #     {
   #   #       'name'    => 'username/moduledep',
   #   #       'version' => '1.2.3',
   #   #       'version_requirement' => '>= 1.0.0',
   #   #     },
   #   #     {
   #   #       'name'    => 'username/anotherdep',
   #   #       'version' => '4.5.6',
   #   #       'version_requirement' => '>= 3.0.0',
   #   #     }
   #   #   ]
   #   # }
   #   #
   #
   # @return [Hash<String, Array<Hash<String, String>>>] See the method example
   #   for an explanation of the return value.
   def module_requirements
     deps = {}
 
     modules.each do |mod|
       next unless mod.forge_name
       deps[mod.forge_name] ||= []
 
       mod.dependencies and mod.dependencies.each do |mod_dep|
         dep_name = mod_dep['name'].tr('-', '/')
         (deps[dep_name] ||= []) << {
           'name'                => mod.forge_name,
           'version'             => mod.version,
           'version_requirement' => mod_dep['version_requirement']
         }
       end
     end
 
     deps.each do |mod, mod_deps|
       deps[mod] = mod_deps.sort_by { |d| d['name'] }
     end
 
     deps
   end
 
   # Set a periodic watcher on the file, so we can tell if it has changed.
   # If watching has been turned off, this call has no effect.
   # @param file[File,String] File instance or filename
   # @api private
   def watch_file(file)
     if watching?
       known_resource_types.watch_file(file.to_s)
     end
   end
 
   # Checks if a reparse is required (cache of files is stale).
   # This call does nothing unless files are being watched.
   #
   def check_for_reparse
     if (Puppet[:code] != @parsed_code) || (watching? && @known_resource_types && @known_resource_types.require_reparse?)
       @parsed_code = nil
       @known_resource_types = nil
     end
   end
 
+  # @return [String] The YAML interpretation of the object
+  # Return the name of the environment as a string interpretation of the object
+  def to_yaml
+    to_s.to_yaml
+  end
+
   # @return [String] The stringified value of the `name` instance variable
   # @api public
   def to_s
     name.to_s
   end
 
   # @return [Symbol] The `name` value, cast to a string, then cast to a symbol.
   #
   # @api public
   #
   # @note the `name` instance variable is a Symbol, but this casts the value
   #   to a String and then converts it back into a Symbol which will needlessly
   #   create an object that needs to be garbage collected
   def to_sym
     to_s.to_sym
   end
 
-  # Return only the environment name when serializing.
-  #
-  # The only thing we care about when serializing an environment is its
-  # identity; everything else is ephemeral and should not be stored or
-  # transmitted.
-  #
-  # @api public
-  def to_zaml(z)
-    self.to_s.to_zaml(z)
-  end
-
   def self.split_path(path_string)
     path_string.split(File::PATH_SEPARATOR)
   end
 
   def ==(other)
     return true if other.kind_of?(Puppet::Node::Environment) &&
       self.name == other.name &&
       self.full_modulepath == other.full_modulepath &&
       self.manifest == other.manifest
   end
 
   alias eql? ==
 
   def hash
     [self.class, name, full_modulepath, manifest].hash
   end
 
   private
 
   def self.extralibs()
     if ENV["PUPPETLIB"]
       split_path(ENV["PUPPETLIB"])
     else
       []
     end
   end
 
   def self.expand_dirs(dirs)
     dirs.collect do |dir|
       File.expand_path(dir)
     end
   end
 
   # Reparse the manifests for the given environment
   #
   # There are two sources that can be used for the initial parse:
   #
   #   1. The value of `Puppet.settings[:code]`: Puppet can take a string from
   #     its settings and parse that as a manifest. This is used by various
   #     Puppet applications to read in a manifest and pass it to the
   #     environment as a side effect. This is attempted first.
   #   2. The contents of `Puppet.settings[:manifest]`: Puppet will try to load
   #     the environment manifest. By default this is `$manifestdir/site.pp`
   #
   # @note This method will return an empty hostclass if
   #   `Puppet.settings[:ignoreimport]` is set to true.
   #
   # @return [Puppet::Parser::AST::Hostclass] The AST hostclass object
   #   representing the 'main' hostclass
   def perform_initial_import
     return empty_parse_result if Puppet[:ignoreimport]
     parser = Puppet::Parser::ParserFactory.parser(self)
     @parsed_code = Puppet[:code]
     if @parsed_code != ""
       parser.string = @parsed_code
       parser.parse
     else
       file = self.manifest
       # if the manifest file is a reference to a directory, parse and combine all .pp files in that
       # directory
       if file == NO_MANIFEST
         Puppet::Parser::AST::Hostclass.new('')
       elsif File.directory?(file)
         if Puppet[:parser] == 'future'
           parse_results = Puppet::FileSystem::PathPattern.absolute(File.join(file, '**/*.pp')).glob.sort.map do | file_to_parse |
             parser.file = file_to_parse
             parser.parse
           end
         else
           parse_results = Dir.entries(file).find_all { |f| f =~ /\.pp$/ }.sort.map do |file_to_parse|
             parser.file = File.join(file, file_to_parse)
             parser.parse
           end
         end
         # Use a parser type specific merger to concatenate the results
         Puppet::Parser::AST::Hostclass.new('', :code => Puppet::Parser::ParserFactory.code_merger.concatenate(parse_results))
       else
         parser.file = file
         parser.parse
       end
     end
   rescue => detail
     @known_resource_types.parse_failed = true
 
     msg = "Could not parse for environment #{self}: #{detail}"
     error = Puppet::Error.new(msg)
     error.set_backtrace(detail.backtrace)
     raise error
   end
 
   # Return an empty toplevel hostclass to indicate that no file was loaded
   #
   # This is used as the return value of {#perform_initial_import} when
   # `Puppet.settings[:ignoreimport]` is true.
   #
   # @return [Puppet::Parser::AST::Hostclass]
   def empty_parse_result
     return Puppet::Parser::AST::Hostclass.new('')
   end
 
   # A special "null" environment
   #
   # This environment should be used when there is no specific environment in
   # effect.
   NONE = create(:none, [])
 end
diff --git a/lib/puppet/util/monkey_patches.rb b/lib/puppet/util/monkey_patches.rb
index 2819d6382..6b1c886a9 100644
--- a/lib/puppet/util/monkey_patches.rb
+++ b/lib/puppet/util/monkey_patches.rb
@@ -1,217 +1,204 @@
 module Puppet::Util::MonkeyPatches
 end
 
 begin
   Process.maxgroups = 1024
 rescue Exception
   # Actually, I just want to ignore it, since various platforms - JRuby,
   # Windows, and so forth - don't support it, but only because it isn't a
   # meaningful or implementable concept there.
 end
 
 module RDoc
   def self.caller(skip=nil)
     in_gem_wrapper = false
     Kernel.caller.reject { |call|
       in_gem_wrapper ||= call =~ /#{Regexp.escape $0}:\d+:in `load'/
     }
   end
 end
 
 
 require "yaml"
-require "puppet/util/zaml.rb"
 
 class Symbol
   def <=> (other)
     self.to_s <=> other.to_s
   end unless method_defined? '<=>'
 
   def intern
     self
   end unless method_defined? 'intern'
 end
 
-[Object, Exception, Integer, Struct, Date, Time, Range, Regexp, Hash, Array, Float, String, FalseClass, TrueClass, Symbol, NilClass, Class].each { |cls|
-  cls.class_eval do
-    def to_yaml(ignored=nil)
-      ZAML.dump(self)
-    end
-  end
-}
-
-def YAML.dump(*args)
-  ZAML.dump(*args)
-end
-
 #
 # Workaround for bug in MRI 1.8.7, see
 #     http://redmine.ruby-lang.org/issues/show/2708
 # for details
 #
 if RUBY_VERSION == '1.8.7'
   class NilClass
     def closed?
       true
     end
   end
 end
 
 class Object
   # ActiveSupport 2.3.x mixes in a dangerous method
   # that can cause rspec to fork bomb
   # and other strange things like that.
   def daemonize
     raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
   end
 end
 
 class Symbol
   # So, it turns out that one of the biggest memory allocation hot-spots in our
   # code was using symbol-to-proc - because it allocated a new instance every
   # time it was called, rather than caching (in Ruby 1.8.7 and earlier).
   #
   # In Ruby 1.9.3 and later Symbol#to_proc does implement a cache so we skip
   # our monkey patch.
   #
   # Changing this means we can see XX memory reduction...
   if RUBY_VERSION < "1.9.3"
     if method_defined? :to_proc
       alias __original_to_proc to_proc
       def to_proc
         @my_proc ||= __original_to_proc
       end
     else
       def to_proc
         @my_proc ||= Proc.new {|*args| args.shift.__send__(self, *args) }
       end
     end
   end
 
   # Defined in 1.9, absent in 1.8, and used for compatibility in various
   # places, typically in third party gems.
   def intern
     return self
   end unless method_defined? :intern
 end
 
 class String
   unless method_defined? :lines
     require 'puppet/util/monkey_patches/lines'
     include Puppet::Util::MonkeyPatches::Lines
   end
 end
 
 require 'fcntl'
 class IO
   unless method_defined? :lines
     require 'puppet/util/monkey_patches/lines'
     include Puppet::Util::MonkeyPatches::Lines
   end
 
   def self.binwrite(name, string, offset = nil)
     # Determine if we should truncate or not.  Since the truncate method on a
     # file handle isn't implemented on all platforms, safer to do this in what
     # looks like the libc / POSIX flag - which is usually pretty robust.
     # --daniel 2012-03-11
     mode = Fcntl::O_CREAT | Fcntl::O_WRONLY | (offset.nil? ? Fcntl::O_TRUNC : 0)
 
     # We have to duplicate the mode because Ruby on Windows is a bit precious,
     # and doesn't actually carry over the mode.  It won't work to just use
     # open, either, because that doesn't like our system modes and the default
     # open bits don't do what we need, which is awesome. --daniel 2012-03-30
     IO.open(IO::sysopen(name, mode), mode) do |f|
       # ...seek to our desired offset, then write the bytes.  Don't try to
       # seek past the start of the file, eh, because who knows what platform
       # would legitimately blow up if we did that.
       #
       # Double-check the positioning, too, since destroying data isn't my idea
       # of a good time. --daniel 2012-03-11
       target = [0, offset.to_i].max
       unless (landed = f.sysseek(target, IO::SEEK_SET)) == target
         raise "unable to seek to target offset #{target} in #{name}: got to #{landed}"
       end
 
       f.syswrite(string)
     end
   end unless singleton_methods.include?(:binwrite)
 end
 
 class Float
   INFINITY = (1.0/0.0) if defined?(Float::INFINITY).nil?
 end
 
 class Range
   def intersection(other)
     raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
     return unless other === self.first || self === other.first
 
     start = [self.first, other.first].max
     if self.exclude_end? && self.last <= other.last
       start ... self.last
     elsif other.exclude_end? && self.last >= other.last
       start ... other.last
     else
       start .. [ self.last, other.last ].min
     end
   end unless method_defined? :intersection
 
   alias_method :&, :intersection unless method_defined? :&
 end
 
 # (#19151) Reject all SSLv2 ciphers and handshakes
 require 'openssl'
 class OpenSSL::SSL::SSLContext
   if DEFAULT_PARAMS[:options]
     DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
   else
     DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
   end
   DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
 
   alias __original_initialize initialize
   private :__original_initialize
 
   def initialize(*args)
     __original_initialize(*args)
     params = {
       :options => DEFAULT_PARAMS[:options],
       :ciphers => DEFAULT_PARAMS[:ciphers],
     }
     set_params(params)
   end
 end
 
 require 'puppet/util/platform'
 if Puppet::Util::Platform.windows?
   require 'puppet/util/windows'
   require 'openssl'
 
   class OpenSSL::X509::Store
     alias __original_set_default_paths set_default_paths
     def set_default_paths
       # This can be removed once openssl integrates with windows
       # cert store, see http://rt.openssl.org/Ticket/Display.html?id=2158
       Puppet::Util::Windows::RootCerts.instance.to_a.uniq.each do |x509|
         begin
           add_cert(x509)
         rescue OpenSSL::X509::StoreError => e
           warn "Failed to add #{x509.subject.to_s}"
         end
       end
 
       __original_set_default_paths
     end
   end
 end
 
 # Older versions of SecureRandom (e.g. in 1.8.7) don't have the uuid method
 module SecureRandom
   def self.uuid
     # Copied from the 1.9.1 stdlib implementation of uuid
     ary = self.random_bytes(16).unpack("NnnnnN")
     ary[2] = (ary[2] & 0x0fff) | 0x4000
     ary[3] = (ary[3] & 0x3fff) | 0x8000
     "%08x-%04x-%04x-%04x-%04x%08x" % ary
   end unless singleton_methods.include?(:uuid)
 end
diff --git a/lib/puppet/util/psych_support.rb b/lib/puppet/util/psych_support.rb
index a86229acd..67ee0732b 100644
--- a/lib/puppet/util/psych_support.rb
+++ b/lib/puppet/util/psych_support.rb
@@ -1,24 +1,38 @@
 # This module should be included when a class can be serialized to yaml and
 # needs to handle the deserialization from Psych with more control. Psych normall
 # pokes values directly into an instance using `instance_variable_set` which completely
 # bypasses encapsulation.
 #
 # The class that includes this module must implement an instance method `initialize_from_hash`
 # that is given a hash with attribute to value mappings.
 #
 module Puppet::Util::PsychSupport
   # This method is called from the Psych Yaml deserializer.
   # The serializer calls this instead of doing the initialization itself using
   # `instance_variable_set`. The Status class requires this because it serializes its TagSet
   # as an `Array` in order to optimize the size of the serialized result.
   # When this array is later deserialized it must be reincarnated as a TagSet. The standard
   # Psych way of doing this via poking values into instance variables cannot do this.
   #
   def init_with(psych_coder)
     # The PsychCoder has a hashmap of instance variable name (sans the @ symbol) to values
     # to set, and can thus directly be fed to initialize_from_hash.
     #
     initialize_from_hash(psych_coder.map)
   end
 
-end
\ No newline at end of file
+  # This method is called from the Psych Yaml serializer
+  # The serializer will call this method to create a hash that will be serialized to YAML.
+  # Instead of using the object itself during the mapping process we use what is
+  # returned by calling `to_data_hash` on the object itself since some of the
+  # objects we manage have asymmetrical serialization and deserialization.
+  #
+  def encode_with(psych_encoder)
+    tag = Psych.dump_tags[self.class]
+    unless tag
+      klass = self.class == Object ? nil : self.class.name
+      tag   = ['!ruby/object', klass].compact.join(':')
+    end
+    psych_encoder.represent_map(tag, to_data_hash)
+  end
+end
diff --git a/lib/puppet/util/rails/reference_serializer.rb b/lib/puppet/util/rails/reference_serializer.rb
index 9beeb0048..2ea33cb3c 100644
--- a/lib/puppet/util/rails/reference_serializer.rb
+++ b/lib/puppet/util/rails/reference_serializer.rb
@@ -1,32 +1,34 @@
 
 module Puppet::Util::ReferenceSerializer
   def unserialize_value(val)
     case val
-    when /^--- /
+    # Different YAML serializers will format headers differently. If we see a
+    # line that begins with '---' we will assume that it is YAML.
+    when /^---/
       YAML.load(val)
     when "true"
       true
     when "false"
       false
     else
       val
     end
   end
 
   def serialize_value(val)
     case val
     when Puppet::Resource
       YAML.dump(val)
     when true, false
       # The database does this for us, but I prefer the
       # methods be their exact inverses.
       # Note that this means quoted booleans get returned
       # as actual booleans, but there doesn't appear to be
       # a way to fix that while keeping the ability to
       # search for parameters set to true.
       val.to_s
     else
       val
     end
   end
 end
diff --git a/lib/puppet/util/tag_set.rb b/lib/puppet/util/tag_set.rb
index e74f228f7..613859d98 100644
--- a/lib/puppet/util/tag_set.rb
+++ b/lib/puppet/util/tag_set.rb
@@ -1,36 +1,30 @@
 require 'set'
 require 'puppet/network/format_support'
 
 class Puppet::Util::TagSet < Set
   include Puppet::Network::FormatSupport
 
   def self.from_yaml(yaml)
     self.new(YAML.load(yaml))
   end
 
   def to_yaml
     @hash.keys.to_yaml
   end
 
   def self.from_data_hash(data)
     self.new(data)
   end
 
   def to_data_hash
     to_a
   end
 
   def to_pson(*args)
     to_data_hash.to_pson
   end
 
-  # this makes puppet serialize it as an array for backwards
-  # compatibility
-  def to_zaml(z)
-    to_data_hash.to_zaml(z)
-  end
-
   def join(*args)
     to_a.join(*args)
   end
 end
diff --git a/lib/puppet/util/zaml.rb b/lib/puppet/util/zaml.rb
deleted file mode 100644
index 510910241..000000000
--- a/lib/puppet/util/zaml.rb
+++ /dev/null
@@ -1,419 +0,0 @@
-# encoding: UTF-8
-#
-# The above encoding line is a magic comment to set the default source encoding
-# of this file for the Ruby interpreter.  It must be on the first or second
-# line of the file if an interpreter is in use.  In Ruby 1.9 and later, the
-# source encoding determines the encoding of String and Regexp objects created
-# from this source file.  This explicit encoding is important because otherwise
-# Ruby will pick an encoding based on LANG or LC_CTYPE environment variables.
-# These may be different from site to site so it's important for us to
-# establish a consistent behavior.  For more information on M17n please see:
-# http://links.puppetlabs.com/understanding_m17n
-
-# ZAML -- A partial replacement for YAML, writen with speed and code clarity
-#         in mind.  ZAML fixes one YAML bug (loading Exceptions) and provides
-#         a replacement for YAML.dump unimaginatively called ZAML.dump,
-#         which is faster on all known cases and an order of magnitude faster
-#         with complex structures.
-#
-# http://github.com/hallettj/zaml
-#
-# ## License (from upstream)
-#
-# Copyright (c) 2008-2009 ZAML contributers
-#
-# This program is dual-licensed under the GNU General Public License
-# version 3 or later and under the Apache License, version 2.0.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by the
-# Free Software Foundation, either version 3 of the License, or (at your
-# option) any later version; or under the terms of the Apache License,
-# Version 2.0.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License and the Apache License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see
-# <http://www.gnu.org/licenses/>.
-#
-# You may obtain a copy of the Apache License at
-# <https://www.apache.org/licenses/LICENSE-2.0.html>.
-
-require 'yaml'
-
-class ZAML
-  VERSION = "0.1.3"
-  #
-  # Class Methods
-  #
-  def self.dump(stuff, where='')
-    z = new
-    stuff.to_zaml(z)
-    where << z.to_s
-  end
-
-  #
-  # Instance Methods
-  #
-  def initialize
-    @result = []
-    @indent = nil
-    @structured_key_prefix = nil
-    @previously_emitted_object = {}
-    @next_free_label_number = 0
-    emit('--- ')
-  end
-
-  def nested(tail='  ')
-    old_indent = @indent
-    @indent = "#{@indent || "\n"}#{tail}"
-    yield
-    @indent = old_indent
-  end
-
-  class Label
-    #
-    # YAML only wants objects in the datastream once; if the same object
-    #    occurs more than once, we need to emit a label ("&idxxx") on the
-    #    first occurrence and then emit a back reference (*idxxx") on any
-    #    subsequent occurrence(s).
-    #
-    # To accomplish this we keeps a hash (by object id) of the labels of
-    #    the things we serialize as we begin to serialize them.  The labels
-    #    initially serialize as an empty string (since most objects are only
-    #    going to be be encountered once), but can be changed to a valid
-    #    (by assigning it a number) the first time it is subsequently used,
-    #    if it ever is.  Note that we need to do the label setup BEFORE we
-    #    start to serialize the object so that circular structures (in
-    #    which we will encounter a reference to the object as we serialize
-    #    it can be handled).
-    #
-    attr_accessor :this_label_number
-
-    def initialize(obj,indent)
-      @indent = indent
-      @this_label_number = nil
-      @obj = obj # prevent garbage collection so that object id isn't reused
-    end
-
-    def to_s
-      @this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : ''
-    end
-
-    def reference
-      @reference         ||= '*id%03d' % @this_label_number
-    end
-  end
-
-  def label_for(obj)
-    @previously_emitted_object[obj.object_id]
-  end
-
-  def new_label_for(obj)
-    label = Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"}  " : ' ')
-    @previously_emitted_object[obj.object_id] = label
-    label
-  end
-
-  def first_time_only(obj)
-    if label = label_for(obj)
-      label.this_label_number ||= (@next_free_label_number += 1)
-      emit(label.reference)
-    else
-      with_structured_prefix(obj) do
-        emit(new_label_for(obj))
-        yield
-      end
-    end
-  end
-
-  def with_structured_prefix(obj)
-    if @structured_key_prefix
-      unless obj.is_a?(String) and obj !~ /\n/
-        emit(@structured_key_prefix)
-        @structured_key_prefix = nil
-      end
-    end
-    yield
-  end
-
-  def emit(s)
-    @result << s
-    @recent_nl = false unless s.kind_of?(Label)
-  end
-
-  def nl(s = nil)
-    emit(@indent || "\n") unless @recent_nl
-    emit(s) if s
-    @recent_nl = true
-  end
-
-  def to_s
-    @result.join
-  end
-
-  def prefix_structured_keys(x)
-    @structured_key_prefix = x
-    yield
-    nl unless @structured_key_prefix
-    @structured_key_prefix = nil
-  end
-end
-
-################################################################
-#
-#   Behavior for custom classes
-#
-################################################################
-
-class Object
-  # Users of this method need to do set math consistently with the
-  # result. Since #instance_variables returns strings in 1.8 and symbols
-  # on 1.9, standardize on symbols
-  if RUBY_VERSION[0,3] == '1.8'
-    def to_yaml_properties
-      instance_variables.map(&:to_sym)
-    end
-  else
-    def to_yaml_properties
-      instance_variables
-    end
-  end
-
-  def yaml_property_munge(x)
-    x
-  end
-
-  def zamlized_class_name(root)
-    cls = self.class
-    "!ruby/#{root.name.downcase}#{cls == root ? '' : ":#{cls.respond_to?(:name) ? cls.name : cls}"}"
-  end
-
-  def to_zaml(z)
-    z.first_time_only(self) {
-      z.emit(zamlized_class_name(Object))
-      z.nested {
-        instance_variables = to_yaml_properties
-        if instance_variables.empty?
-          z.emit(" {}")
-        else
-          instance_variables.each { |v|
-            z.nl
-            v.to_s[1..-1].to_zaml(z)       # Remove leading '@'
-            z.emit(': ')
-            yaml_property_munge(instance_variable_get(v)).to_zaml(z)
-          }
-        end
-      }
-    }
-  end
-end
-
-################################################################
-#
-#   Behavior for built-in classes
-#
-################################################################
-
-class NilClass
-  def to_zaml(z)
-    z.emit('')        # NOTE: blank turns into nil in YAML.load
-  end
-end
-
-class Symbol
-  def to_zaml(z)
-    z.emit("!ruby/sym ")
-    to_s.to_zaml(z)
-  end
-end
-
-class TrueClass
-  def to_zaml(z)
-    z.emit('true')
-  end
-end
-
-class FalseClass
-  def to_zaml(z)
-    z.emit('false')
-  end
-end
-
-class Numeric
-  def to_zaml(z)
-    z.emit(self)
-  end
-end
-
-class Regexp
-  def to_zaml(z)
-    z.first_time_only(self) { z.emit("#{zamlized_class_name(Regexp)} #{inspect}") }
-  end
-end
-
-class Exception
-  def to_zaml(z)
-    z.emit(zamlized_class_name(Exception))
-    z.nested {
-      z.nl("message: ")
-      message.to_zaml(z)
-    }
-  end
-  #
-  # Monkey patch for buggy Exception restore in YAML
-  #
-  #     This makes it work for now but is not very future-proof; if things
-  #     change we'll most likely want to remove this.  To mitigate the risks
-  #     as much as possible, we test for the bug before appling the patch.
-  #
-  if respond_to? :yaml_new and yaml_new(self, :tag, "message" => "blurp").message != "blurp"
-    def self.yaml_new( klass, tag, val )
-      o = YAML.object_maker( klass, {} ).exception(val.delete( 'message'))
-      val.each_pair do |k,v|
-        o.instance_variable_set("@#{k}", v)
-      end
-      o
-    end
-  end
-end
-
-class String
-  ZAML_ESCAPES = {
-    "\a" => "\\a", "\e" => "\\e", "\f" => "\\f", "\n" => "\\n",
-    "\r" => "\\r", "\t" => "\\t", "\v" => "\\v"
-  }
-
-  def to_zaml(z)
-    z.with_structured_prefix(self) do
-      case
-      when self == ''
-        z.emit('""')
-      when self.to_ascii8bit !~ /\A(?: # ?: non-capturing group (grouping with no back references)
-                 [\x09\x0A\x0D\x20-\x7E]            # ASCII
-               | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
-               |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
-               | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
-               |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
-               |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
-               | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
-               |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
-               )*\z/mnx
-        # Emit the binary tag, then recurse. Ruby splits BASE64 output at the 60
-        # character mark when packing strings, and we can wind up a multi-line
-        # string here.  We could reimplement the multi-line string logic,
-        # but why would we - this does just as well for producing solid output.
-        z.emit("!binary ")
-        [self].pack("m*").to_zaml(z)
-
-      # Only legal UTF-8 characters can make it this far, so we are safe
-      # against emitting something dubious. That means we don't need to mess
-      # about, just emit them directly. --daniel 2012-07-14
-      when ((self =~ /\A[a-zA-Z\/][-\[\]_\/.a-zA-Z0-9]*\z/) and
-          (self !~ /^(?:true|false|yes|no|on|null|off)$/i))
-        # simple string literal, safe to emit unquoted.
-        z.emit(self)
-      when (self =~ /\n/ and self !~ /\A\s/ and self !~ /\s\z/)
-        # embedded newline, split line-wise in quoted string block form.
-        if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
-        z.nested { split("\n",-1).each { |line| z.nl; z.emit(line) } }
-      else
-        # ...though we still have to escape unsafe characters.
-        escaped = gsub(/[\\"\x00-\x1F]/) do |c|
-          ZAML_ESCAPES[c] || "\\x#{c[0].ord.to_s(16)}"
-        end
-        z.emit("\"#{escaped}\"")
-      end
-    end
-  end
-
-  # Return a guranteed ASCII-8BIT encoding for Ruby 1.9 This is a helper
-  # method for other methods that perform regular expressions against byte
-  # sequences deliberately rather than dealing with characters.
-  # The method may or may not return a new instance.
-  if String.method_defined?(:encoding)
-    ASCII_ENCODING = Encoding.find("ASCII-8BIT")
-    def to_ascii8bit
-      if self.encoding == ASCII_ENCODING
-        self
-      else
-        self.dup.force_encoding(ASCII_ENCODING)
-      end
-    end
-  else
-    def to_ascii8bit
-      self
-    end
-  end
-end
-
-class Hash
-  def to_zaml(z)
-    z.first_time_only(self) {
-      z.nested {
-        if empty?
-          z.emit('{}')
-        else
-          each_pair { |k, v|
-            z.nl
-            z.prefix_structured_keys('? ') { k.to_zaml(z) }
-            z.emit(': ')
-            v.to_zaml(z)
-          }
-        end
-      }
-    }
-  end
-end
-
-class Array
-  def to_zaml(z)
-    z.first_time_only(self) {
-      z.nested {
-        if empty?
-          z.emit('[]')
-        else
-          each { |v| z.nl('- '); v.to_zaml(z) }
-        end
-      }
-    }
-  end
-end
-
-class Time
-  def to_zaml(z)
-    # 2008-12-06 10:06:51.373758 -07:00
-    ms = ("%0.6f" % (usec * 1e-6))[2..-1]
-    offset = "%+0.2i:%0.2i" % [utc_offset / 3600.0, (utc_offset / 60) % 60]
-    z.emit(self.strftime("%Y-%m-%d %H:%M:%S.#{ms} #{offset}"))
-  end
-end
-
-class Date
-  def to_zaml(z)
-    z.emit(strftime('%Y-%m-%d'))
-  end
-end
-
-class Range
-  def to_zaml(z)
-    z.first_time_only(self) {
-      z.emit(zamlized_class_name(Range))
-      z.nested {
-        z.nl
-        z.emit('begin: ')
-        z.emit(first)
-        z.nl
-        z.emit('end: ')
-        z.emit(last)
-        z.nl
-        z.emit('excl: ')
-        z.emit(exclude_end?)
-      }
-    }
-  end
-end
diff --git a/spec/unit/graph/simple_graph.rb b/spec/unit/graph/simple_graph.rb
index 0f43d3523..c6fe8b3ab 100755
--- a/spec/unit/graph/simple_graph.rb
+++ b/spec/unit/graph/simple_graph.rb
@@ -1,721 +1,721 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/graph'
 
 describe Puppet::Graph::SimpleGraph do
   it "should return the number of its vertices as its length" do
     @graph = Puppet::Graph::SimpleGraph.new
     @graph.add_vertex("one")
     @graph.add_vertex("two")
     @graph.size.should == 2
   end
 
   it "should consider itself a directed graph" do
     Puppet::Graph::SimpleGraph.new.directed?.should be_true
   end
 
   it "should provide a method for reversing the graph" do
     @graph = Puppet::Graph::SimpleGraph.new
     @graph.add_edge(:one, :two)
     @graph.reversal.edge?(:two, :one).should be_true
   end
 
   it "should be able to produce a dot graph" do
     @graph = Puppet::Graph::SimpleGraph.new
     @graph.add_edge(:one, :two)
 
     expect { @graph.to_dot_graph }.to_not raise_error
   end
 
   describe "when managing vertices" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
     end
 
     it "should provide a method to add a vertex" do
       @graph.add_vertex(:test)
       @graph.vertex?(:test).should be_true
     end
 
     it "should reset its reversed graph when vertices are added" do
       rev = @graph.reversal
       @graph.add_vertex(:test)
       @graph.reversal.should_not equal(rev)
     end
 
     it "should ignore already-present vertices when asked to add a vertex" do
       @graph.add_vertex(:test)
       expect { @graph.add_vertex(:test) }.to_not raise_error
     end
 
     it "should return true when asked if a vertex is present" do
       @graph.add_vertex(:test)
       @graph.vertex?(:test).should be_true
     end
 
     it "should return false when asked if a non-vertex is present" do
       @graph.vertex?(:test).should be_false
     end
 
     it "should return all set vertices when asked" do
       @graph.add_vertex(:one)
       @graph.add_vertex(:two)
       @graph.vertices.length.should == 2
       @graph.vertices.should include(:one)
       @graph.vertices.should include(:two)
     end
 
     it "should remove a given vertex when asked" do
       @graph.add_vertex(:one)
       @graph.remove_vertex!(:one)
       @graph.vertex?(:one).should be_false
     end
 
     it "should do nothing when a non-vertex is asked to be removed" do
       expect { @graph.remove_vertex!(:one) }.to_not raise_error
     end
   end
 
   describe "when managing edges" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
     end
 
     it "should provide a method to test whether a given vertex pair is an edge" do
       @graph.should respond_to(:edge?)
     end
 
     it "should reset its reversed graph when edges are added" do
       rev = @graph.reversal
       @graph.add_edge(:one, :two)
       @graph.reversal.should_not equal(rev)
     end
 
     it "should provide a method to add an edge as an instance of the edge class" do
       edge = Puppet::Relationship.new(:one, :two)
       @graph.add_edge(edge)
       @graph.edge?(:one, :two).should be_true
     end
 
     it "should provide a method to add an edge by specifying the two vertices" do
       @graph.add_edge(:one, :two)
       @graph.edge?(:one, :two).should be_true
     end
 
     it "should provide a method to add an edge by specifying the two vertices and a label" do
       @graph.add_edge(:one, :two, :callback => :awesome)
       @graph.edge?(:one, :two).should be_true
     end
 
     describe "when retrieving edges between two nodes" do
       it "should handle the case of nodes not in the graph" do
         @graph.edges_between(:one, :two).should == []
       end
 
       it "should handle the case of nodes with no edges between them" do
         @graph.add_vertex(:one)
         @graph.add_vertex(:two)
         @graph.edges_between(:one, :two).should == []
       end
 
       it "should handle the case of nodes connected by a single edge" do
         edge = Puppet::Relationship.new(:one, :two)
         @graph.add_edge(edge)
         @graph.edges_between(:one, :two).length.should == 1
         @graph.edges_between(:one, :two)[0].should equal(edge)
       end
 
       it "should handle the case of nodes connected by multiple edges" do
         edge1 = Puppet::Relationship.new(:one, :two, :callback => :foo)
         edge2 = Puppet::Relationship.new(:one, :two, :callback => :bar)
         @graph.add_edge(edge1)
         @graph.add_edge(edge2)
         Set.new(@graph.edges_between(:one, :two)).should == Set.new([edge1, edge2])
       end
     end
 
     it "should add the edge source as a vertex if it is not already" do
       edge = Puppet::Relationship.new(:one, :two)
       @graph.add_edge(edge)
       @graph.vertex?(:one).should be_true
     end
 
     it "should add the edge target as a vertex if it is not already" do
       edge = Puppet::Relationship.new(:one, :two)
       @graph.add_edge(edge)
       @graph.vertex?(:two).should be_true
     end
 
     it "should return all edges as edge instances when asked" do
       one = Puppet::Relationship.new(:one, :two)
       two = Puppet::Relationship.new(:two, :three)
       @graph.add_edge(one)
       @graph.add_edge(two)
       edges = @graph.edges
       edges.should be_instance_of(Array)
       edges.length.should == 2
       edges.should include(one)
       edges.should include(two)
     end
 
     it "should remove an edge when asked" do
       edge = Puppet::Relationship.new(:one, :two)
       @graph.add_edge(edge)
       @graph.remove_edge!(edge)
       @graph.edge?(edge.source, edge.target).should be_false
     end
 
     it "should remove all related edges when a vertex is removed" do
       one = Puppet::Relationship.new(:one, :two)
       two = Puppet::Relationship.new(:two, :three)
       @graph.add_edge(one)
       @graph.add_edge(two)
       @graph.remove_vertex!(:two)
       @graph.edge?(:one, :two).should be_false
       @graph.edge?(:two, :three).should be_false
       @graph.edges.length.should == 0
     end
   end
 
   describe "when finding adjacent vertices" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
       @one_two = Puppet::Relationship.new(:one, :two)
       @two_three = Puppet::Relationship.new(:two, :three)
       @one_three = Puppet::Relationship.new(:one, :three)
       @graph.add_edge(@one_two)
       @graph.add_edge(@one_three)
       @graph.add_edge(@two_three)
     end
 
     it "should return adjacent vertices" do
       adj = @graph.adjacent(:one)
       adj.should be_include(:three)
       adj.should be_include(:two)
     end
 
     it "should default to finding :out vertices" do
       @graph.adjacent(:two).should == [:three]
     end
 
     it "should support selecting :in vertices" do
       @graph.adjacent(:two, :direction => :in).should == [:one]
     end
 
     it "should default to returning the matching vertices as an array of vertices" do
       @graph.adjacent(:two).should == [:three]
     end
 
     it "should support returning an array of matching edges" do
       @graph.adjacent(:two, :type => :edges).should == [@two_three]
     end
 
     # Bug #2111
     it "should not consider a vertex adjacent just because it was asked about previously" do
       @graph = Puppet::Graph::SimpleGraph.new
       @graph.add_vertex("a")
       @graph.add_vertex("b")
       @graph.edge?("a", "b")
       @graph.adjacent("a").should == []
     end
   end
 
   describe "when clearing" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
       one = Puppet::Relationship.new(:one, :two)
       two = Puppet::Relationship.new(:two, :three)
       @graph.add_edge(one)
       @graph.add_edge(two)
 
       @graph.clear
     end
 
     it "should remove all vertices" do
       @graph.vertices.should be_empty
     end
 
     it "should remove all edges" do
       @graph.edges.should be_empty
     end
   end
 
   describe "when reversing graphs" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
     end
 
     it "should provide a method for reversing the graph" do
       @graph.add_edge(:one, :two)
       @graph.reversal.edge?(:two, :one).should be_true
     end
 
     it "should add all vertices to the reversed graph" do
       @graph.add_edge(:one, :two)
       @graph.vertex?(:one).should be_true
       @graph.vertex?(:two).should be_true
     end
 
     it "should retain labels on edges" do
       @graph.add_edge(:one, :two, :callback => :awesome)
       edge = @graph.reversal.edges_between(:two, :one)[0]
       edge.label.should == {:callback => :awesome}
     end
   end
 
   describe "when reporting cycles in the graph" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
     end
 
     # This works with `add_edges` to auto-vivify the resource instances.
     let :vertex do
       Hash.new do |hash, key|
         hash[key] = Puppet::Type.type(:notify).new(:name => key.to_s)
       end
     end
 
     def add_edges(hash)
       hash.each do |a,b|
         @graph.add_edge(vertex[a], vertex[b])
       end
     end
 
     def simplify(cycles)
       cycles.map do |cycle|
         cycle.map do |resource|
           resource.name
         end
       end
     end
 
     it "should fail on two-vertex loops" do
       add_edges :a => :b, :b => :a
       expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
     end
 
     it "should fail on multi-vertex loops" do
       add_edges :a => :b, :b => :c, :c => :a
       expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
     end
 
     it "should fail when a larger tree contains a small cycle" do
       add_edges :a => :b, :b => :a, :c => :a, :d => :c
       expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
     end
 
     it "should succeed on trees with no cycles" do
       add_edges :a => :b, :b => :e, :c => :a, :d => :c
       expect { @graph.report_cycles_in_graph }.to_not raise_error
     end
 
     it "should produce the correct relationship text" do
       add_edges :a => :b, :b => :a
       # cycle detection starts from a or b randomly
       # so we need to check for either ordering in the error message
       want = %r{Found 1 dependency cycle:\n\((Notify\[a\] => Notify\[b\] => Notify\[a\]|Notify\[b\] => Notify\[a\] => Notify\[b\])\)\nTry}
       expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error, want)
     end
 
     it "cycle discovery should be the minimum cycle for a simple graph" do
       add_edges "a" => "b"
       add_edges "b" => "a"
       add_edges "b" => "c"
 
       simplify(@graph.find_cycles_in_graph).should be == [["a", "b"]]
     end
 
     it "cycle discovery handles a self-loop cycle" do
       add_edges :a => :a
 
       simplify(@graph.find_cycles_in_graph).should be == [["a"]]
     end
 
     it "cycle discovery should handle two distinct cycles" do
       add_edges "a" => "a1", "a1" => "a"
       add_edges "b" => "b1", "b1" => "b"
 
       simplify(@graph.find_cycles_in_graph).should be == [["a1", "a"], ["b1", "b"]]
     end
 
     it "cycle discovery should handle two cycles in a connected graph" do
       add_edges "a" => "b", "b" => "c", "c" => "d"
       add_edges "a" => "a1", "a1" => "a"
       add_edges "c" => "c1", "c1" => "c2", "c2" => "c3", "c3" => "c"
 
       simplify(@graph.find_cycles_in_graph).should be == [%w{a1 a}, %w{c1 c2 c3 c}]
     end
 
     it "cycle discovery should handle a complicated cycle" do
       add_edges "a" => "b", "b" => "c"
       add_edges "a" => "c"
       add_edges "c" => "c1", "c1" => "a"
       add_edges "c" => "c2", "c2" => "b"
 
       simplify(@graph.find_cycles_in_graph).should be == [%w{a b c1 c2 c}]
     end
 
     it "cycle discovery should not fail with large data sets" do
       limit = 3000
       (1..(limit - 1)).each do |n| add_edges n.to_s => (n+1).to_s end
 
       simplify(@graph.find_cycles_in_graph).should be == []
     end
 
     it "path finding should work with a simple cycle" do
       add_edges "a" => "b", "b" => "c", "c" => "a"
 
       cycles = @graph.find_cycles_in_graph
       paths = @graph.paths_in_cycle(cycles.first, 100)
       simplify(paths).should be == [%w{a b c a}]
     end
 
     it "path finding should work with two independent cycles" do
       add_edges "a" => "b1"
       add_edges "a" => "b2"
       add_edges "b1" => "a", "b2" => "a"
 
       cycles = @graph.find_cycles_in_graph
       cycles.length.should be == 1
 
       paths = @graph.paths_in_cycle(cycles.first, 100)
       simplify(paths).should be == [%w{a b1 a}, %w{a b2 a}]
     end
 
     it "path finding should prefer shorter paths in cycles" do
       add_edges "a" => "b", "b" => "c", "c" => "a"
       add_edges "b" => "a"
 
       cycles = @graph.find_cycles_in_graph
       cycles.length.should be == 1
 
       paths = @graph.paths_in_cycle(cycles.first, 100)
       simplify(paths).should be == [%w{a b a}, %w{a b c a}]
     end
 
     it "path finding should respect the max_path value" do
       (1..20).each do |n| add_edges "a" => "b#{n}", "b#{n}" => "a" end
 
       cycles = @graph.find_cycles_in_graph
       cycles.length.should be == 1
 
       (1..20).each do |n|
         paths = @graph.paths_in_cycle(cycles.first, n)
         paths.length.should be == n
       end
 
       paths = @graph.paths_in_cycle(cycles.first, 21)
       paths.length.should be == 20
     end
   end
 
   describe "when writing dot files" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
       @name = :test
       @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
     end
 
     it "should only write when graphing is enabled" do
       File.expects(:open).with(@file).never
       Puppet[:graph] = false
       @graph.write_graph(@name)
     end
 
     it "should write a dot file based on the passed name" do
       File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil))
       @graph.expects(:to_dot).with("name" => @name.to_s.capitalize)
       Puppet[:graph] = true
       @graph.write_graph(@name)
     end
   end
 
   describe Puppet::Graph::SimpleGraph do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
     end
 
     it "should correctly clear vertices and edges when asked" do
       @graph.add_edge("a", "b")
       @graph.add_vertex "c"
       @graph.clear
       @graph.vertices.should be_empty
       @graph.edges.should be_empty
     end
   end
 
   describe "when matching edges" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
 
       # The Ruby 1.8 semantics for String#[] are that treating it like an
       # array and asking for `"a"[:whatever]` returns `nil`.  Ruby 1.9
       # enforces that your index has to be numeric.
       #
       # Now, the real object here, a resource, implements [] and does
       # something sane, but we don't care about any of the things that get
       # asked for.  Right now, anyway.
       #
       # So, in 1.8 we could just pass a string and it worked.  For 1.9 we can
       # fake it well enough by stubbing out the operator to return nil no
       # matter what input we give. --daniel 2012-03-11
       resource = "a"
       resource.stubs(:[])
       @event = Puppet::Transaction::Event.new(:name => :yay, :resource => resource)
       @none = Puppet::Transaction::Event.new(:name => :NONE, :resource => resource)
 
       @edges = {}
       @edges["a/b"] = Puppet::Relationship.new("a", "b", {:event => :yay, :callback => :refresh})
       @edges["a/c"] = Puppet::Relationship.new("a", "c", {:event => :yay, :callback => :refresh})
       @graph.add_edge(@edges["a/b"])
     end
 
     it "should match edges whose source matches the source of the event" do
       @graph.matching_edges(@event).should == [@edges["a/b"]]
     end
 
     it "should match always match nothing when the event is :NONE" do
       @graph.matching_edges(@none).should be_empty
     end
 
     it "should match multiple edges" do
       @graph.add_edge(@edges["a/c"])
       edges = @graph.matching_edges(@event)
       edges.should be_include(@edges["a/b"])
       edges.should be_include(@edges["a/c"])
     end
   end
 
   describe "when determining dependencies" do
     before do
       @graph = Puppet::Graph::SimpleGraph.new
 
       @graph.add_edge("a", "b")
       @graph.add_edge("a", "c")
       @graph.add_edge("b", "d")
     end
 
     it "should find all dependents when they are on multiple levels" do
       @graph.dependents("a").sort.should == %w{b c d}.sort
     end
 
     it "should find single dependents" do
       @graph.dependents("b").sort.should == %w{d}.sort
     end
 
     it "should return an empty array when there are no dependents" do
       @graph.dependents("c").sort.should == [].sort
     end
 
     it "should find all dependencies when they are on multiple levels" do
       @graph.dependencies("d").sort.should == %w{a b}
     end
 
     it "should find single dependencies" do
       @graph.dependencies("c").sort.should == %w{a}
     end
 
     it "should return an empty array when there are no dependencies" do
       @graph.dependencies("a").sort.should == []
     end
   end
 
   it "should serialize to YAML using the old format by default" do
     Puppet::Graph::SimpleGraph.use_new_yaml_format.should == false
   end
 
   describe "(yaml tests)" do
     def empty_graph(graph)
     end
 
     def one_vertex_graph(graph)
       graph.add_vertex(:a)
     end
 
     def graph_without_edges(graph)
       [:a, :b, :c].each { |x| graph.add_vertex(x) }
     end
 
     def one_edge_graph(graph)
       graph.add_edge(:a, :b)
     end
 
     def many_edge_graph(graph)
       graph.add_edge(:a, :b)
       graph.add_edge(:a, :c)
       graph.add_edge(:b, :d)
       graph.add_edge(:c, :d)
     end
 
     def labeled_edge_graph(graph)
       graph.add_edge(:a, :b, :callback => :foo, :event => :bar)
     end
 
     def overlapping_edge_graph(graph)
       graph.add_edge(:a, :b, :callback => :foo, :event => :bar)
       graph.add_edge(:a, :b, :callback => :biz, :event => :baz)
     end
 
     def self.all_test_graphs
       [:empty_graph, :one_vertex_graph, :graph_without_edges, :one_edge_graph, :many_edge_graph, :labeled_edge_graph,
        :overlapping_edge_graph]
     end
 
     def object_ids(enumerable)
       # Return a sorted list of the object id's of the elements of an
       # enumerable.
       enumerable.collect { |x| x.object_id }.sort
     end
 
     def graph_to_yaml(graph, which_format)
       previous_use_new_yaml_format = Puppet::Graph::SimpleGraph.use_new_yaml_format
       Puppet::Graph::SimpleGraph.use_new_yaml_format = (which_format == :new)
-      ZAML.dump(graph)
+      YAML.dump(graph)
     ensure
       Puppet::Graph::SimpleGraph.use_new_yaml_format = previous_use_new_yaml_format
     end
 
     # Test serialization of graph to YAML.
     [:old, :new].each do |which_format|
       all_test_graphs.each do |graph_to_test|
         it "should be able to serialize #{graph_to_test} to YAML (#{which_format} format)", :if => (RUBY_VERSION[0,3] == '1.8' or YAML::ENGINE.syck?) do
           graph = Puppet::Graph::SimpleGraph.new
           send(graph_to_test, graph)
           yaml_form = graph_to_yaml(graph, which_format)
 
           # Hack the YAML so that objects in the Puppet namespace get
           # changed to YAML::DomainType objects.  This lets us inspect
           # the serialized objects easily without invoking any
           # yaml_initialize hooks.
           yaml_form.gsub!('!ruby/object:Puppet::', '!hack/object:Puppet::')
           serialized_object = YAML.load(yaml_form)
 
           # Check that the object contains instance variables @edges and
           # @vertices only.  @reversal is also permitted, but we don't
           # check it, because it is going to be phased out.
           serialized_object.type_id.should == 'object:Puppet::Graph::SimpleGraph'
           serialized_object.value.keys.reject { |x| x == 'reversal' }.sort.should == ['edges', 'vertices']
 
           # Check edges by forming a set of tuples (source, target,
           # callback, event) based on the graph and the YAML and make sure
           # they match.
           edges = serialized_object.value['edges']
           edges.should be_a(Array)
           expected_edge_tuples = graph.edges.collect { |edge| [edge.source, edge.target, edge.callback, edge.event] }
           actual_edge_tuples = edges.collect do |edge|
             edge.type_id.should == 'object:Puppet::Relationship'
             %w{source target}.each { |x| edge.value.keys.should include(x) }
             edge.value.keys.each { |x| ['source', 'target', 'callback', 'event'].should include(x) }
             %w{source target callback event}.collect { |x| edge.value[x] }
           end
           Set.new(actual_edge_tuples).should == Set.new(expected_edge_tuples)
           actual_edge_tuples.length.should == expected_edge_tuples.length
 
           # Check vertices one by one.
           vertices = serialized_object.value['vertices']
           if which_format == :old
             vertices.should be_a(Hash)
             Set.new(vertices.keys).should == Set.new(graph.vertices)
             vertices.each do |key, value|
               value.type_id.should == 'object:Puppet::Graph::SimpleGraph::VertexWrapper'
               value.value.keys.sort.should == %w{adjacencies vertex}
               value.value['vertex'].should equal(key)
               adjacencies = value.value['adjacencies']
               adjacencies.should be_a(Hash)
               Set.new(adjacencies.keys).should == Set.new([:in, :out])
               [:in, :out].each do |direction|
                 adjacencies[direction].should be_a(Hash)
                 expected_adjacent_vertices = Set.new(graph.adjacent(key, :direction => direction, :type => :vertices))
                 Set.new(adjacencies[direction].keys).should == expected_adjacent_vertices
                 adjacencies[direction].each do |adj_key, adj_value|
                   # Since we already checked edges, just check consistency
                   # with edges.
                   desired_source = direction == :in ? adj_key : key
                   desired_target = direction == :in ? key : adj_key
                   expected_edges = edges.select do |edge|
                     edge.value['source'] == desired_source && edge.value['target'] == desired_target
                   end
                   adj_value.should be_a(Set)
                   if object_ids(adj_value) != object_ids(expected_edges)
                     raise "For vertex #{key.inspect}, direction #{direction.inspect}: expected adjacencies #{expected_edges.inspect} but got #{adj_value.inspect}"
                   end
                 end
               end
             end
           else
             vertices.should be_a(Array)
             Set.new(vertices).should == Set.new(graph.vertices)
             vertices.length.should == graph.vertices.length
           end
         end
       end
 
       # Test deserialization of graph from YAML.  This presumes the
       # correctness of serialization to YAML, which has already been
       # tested.
       all_test_graphs.each do |graph_to_test|
         it "should be able to deserialize #{graph_to_test} from YAML (#{which_format} format)" do
           reference_graph = Puppet::Graph::SimpleGraph.new
           send(graph_to_test, reference_graph)
           yaml_form = graph_to_yaml(reference_graph, which_format)
           recovered_graph = YAML.load(yaml_form)
 
           # Test that the recovered vertices match the vertices in the
           # reference graph.
           expected_vertices = reference_graph.vertices.to_a
           recovered_vertices = recovered_graph.vertices.to_a
           Set.new(recovered_vertices).should == Set.new(expected_vertices)
           recovered_vertices.length.should == expected_vertices.length
 
           # Test that the recovered edges match the edges in the
           # reference graph.
           expected_edge_tuples = reference_graph.edges.collect do |edge|
             [edge.source, edge.target, edge.callback, edge.event]
           end
           recovered_edge_tuples = recovered_graph.edges.collect do |edge|
             [edge.source, edge.target, edge.callback, edge.event]
           end
           Set.new(recovered_edge_tuples).should == Set.new(expected_edge_tuples)
           recovered_edge_tuples.length.should == expected_edge_tuples.length
 
           # We ought to test that the recovered graph is self-consistent
           # too.  But we're not going to bother with that yet because
           # the internal representation of the graph is about to change.
         end
       end
 
       it "should be able to serialize a graph where the vertices contain backreferences to the graph (#{which_format} format)" do
         reference_graph = Puppet::Graph::SimpleGraph.new
         vertex = Object.new
         vertex.instance_eval { @graph = reference_graph }
         reference_graph.add_edge(vertex, :other_vertex)
         yaml_form = graph_to_yaml(reference_graph, which_format)
         recovered_graph = YAML.load(yaml_form)
 
         recovered_graph.vertices.length.should == 2
         recovered_vertex = recovered_graph.vertices.reject { |x| x.is_a?(Symbol) }[0]
         recovered_vertex.instance_eval { @graph }.should equal(recovered_graph)
         recovered_graph.edges.length.should == 1
         recovered_edge = recovered_graph.edges[0]
         recovered_edge.source.should equal(recovered_vertex)
         recovered_edge.target.should == :other_vertex
       end
     end
 
     it "should serialize properly when used as a base class" do
       class Puppet::TestDerivedClass < Puppet::Graph::SimpleGraph
         attr_accessor :foo
       end
       derived = Puppet::TestDerivedClass.new
       derived.add_edge(:a, :b)
       derived.foo = 1234
       recovered_derived = YAML.load(YAML.dump(derived))
       recovered_derived.class.should equal(Puppet::TestDerivedClass)
       recovered_derived.edges.length.should == 1
       recovered_derived.edges[0].source.should == :a
       recovered_derived.edges[0].target.should == :b
       recovered_derived.vertices.length.should == 2
       recovered_derived.foo.should == 1234
     end
   end
 end
diff --git a/spec/unit/indirector/rest_spec.rb b/spec/unit/indirector/rest_spec.rb
index 0ccd405a6..af664ea65 100755
--- a/spec/unit/indirector/rest_spec.rb
+++ b/spec/unit/indirector/rest_spec.rb
@@ -1,570 +1,572 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector'
 require 'puppet/indirector/errors'
 require 'puppet/indirector/rest'
+require 'puppet/util/psych_support'
 
 HTTP_ERROR_CODES = [300, 400, 500]
 
 # Just one from each category since the code makes no real distinctions
 shared_examples_for "a REST terminus method" do |terminus_method|
 
   HTTP_ERROR_CODES.each do |code|
     describe "when the response code is #{code}" do
       let(:response) { mock_response(code, 'error messaged!!!') }
 
       it "raises an http error with the body of the response" do
         expect {
           terminus.send(terminus_method, request)
         }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{response.body}")
       end
 
       it "does not attempt to deserialize the response" do
         model.expects(:convert_from).never
 
         expect {
           terminus.send(terminus_method, request)
         }.to raise_error(Net::HTTPError)
       end
 
       # I'm not sure what this means or if it's used
       it "if the body is empty raises an http error with the response header" do
         response.stubs(:body).returns ""
         response.stubs(:message).returns "fhqwhgads"
 
         expect {
           terminus.send(terminus_method, request)
         }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{response.message}")
       end
 
       describe "and the body is compressed" do
         it "raises an http error with the decompressed body of the response" do
           uncompressed_body = "why"
           compressed_body = Zlib::Deflate.deflate(uncompressed_body)
 
           response = mock_response(code, compressed_body, 'text/plain', 'deflate')
           connection.expects(http_method).returns(response)
 
           expect {
             terminus.send(terminus_method, request)
           }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{uncompressed_body}")
         end
       end
     end
   end
 end
 
 shared_examples_for "a deserializing terminus method" do |terminus_method|
   describe "when the response has no content-type" do
     let(:response) { mock_response(200, "body", nil, nil) }
     it "raises an error" do
       expect {
         terminus.send(terminus_method, request)
       }.to raise_error(RuntimeError, "No content type in http response; cannot parse")
     end
   end
 
   it "doesn't catch errors in deserialization" do
     model.expects(:convert_from).raises(Puppet::Error, "Whoa there")
 
     expect { terminus.send(terminus_method, request) }.to raise_error(Puppet::Error, "Whoa there")
   end
 end
 
 describe Puppet::Indirector::REST do
   before :all do
     class Puppet::TestModel
+      include Puppet::Util::PsychSupport
       extend Puppet::Indirector
       indirects :test_model
       attr_accessor :name, :data
       def initialize(name = "name", data = '')
         @name = name
         @data = data
       end
 
       def self.convert_from(format, string)
         new('', string)
       end
 
       def self.convert_from_multiple(format, string)
         string.split(',').collect { |s| convert_from(format, s) }
       end
 
       def to_data_hash
         { 'name' => @name, 'data' => @data }
       end
 
       def ==(other)
         other.is_a? Puppet::TestModel and other.name == name and other.data == data
       end
     end
 
     # The subclass must not be all caps even though the superclass is
     class Puppet::TestModel::Rest < Puppet::Indirector::REST
     end
 
     Puppet::TestModel.indirection.terminus_class = :rest
   end
 
   after :all do
     Puppet::TestModel.indirection.delete
     # Remove the class, unlinking it from the rest of the system.
     Puppet.send(:remove_const, :TestModel)
   end
 
   let(:terminus_class) { Puppet::TestModel::Rest }
   let(:terminus) { Puppet::TestModel.indirection.terminus(:rest) }
   let(:indirection) { Puppet::TestModel.indirection }
   let(:model) { Puppet::TestModel }
 
   around(:each) do |example|
     Puppet.override(:current_environment => Puppet::Node::Environment.create(:production, [])) do
       example.run
     end
   end
 
   def mock_response(code, body, content_type='text/plain', encoding=nil)
     obj = stub('http 200 ok', :code => code.to_s, :body => body)
     obj.stubs(:[]).with('content-type').returns(content_type)
     obj.stubs(:[]).with('content-encoding').returns(encoding)
     obj.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
     obj
   end
 
   def find_request(key, options={})
     Puppet::Indirector::Request.new(:test_model, :find, key, nil, options)
   end
 
   def head_request(key, options={})
     Puppet::Indirector::Request.new(:test_model, :head, key, nil, options)
   end
 
   def search_request(key, options={})
     Puppet::Indirector::Request.new(:test_model, :search, key, nil, options)
   end
 
   def delete_request(key, options={})
     Puppet::Indirector::Request.new(:test_model, :destroy, key, nil, options)
   end
 
   def save_request(key, instance, options={})
     Puppet::Indirector::Request.new(:test_model, :save, key, instance, options)
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its server" do
     terminus_class.should respond_to(:use_server_setting)
   end
 
   it "should use any specified setting to pick the server" do
     terminus_class.expects(:server_setting).returns :ca_server
     Puppet[:ca_server] = "myserver"
     terminus_class.server.should == "myserver"
   end
 
   it "should default to :server for the server setting" do
     terminus_class.expects(:server_setting).returns nil
     Puppet[:server] = "myserver"
     terminus_class.server.should == "myserver"
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its port" do
     terminus_class.should respond_to(:use_port_setting)
   end
 
   it "should use any specified setting to pick the port" do
     terminus_class.expects(:port_setting).returns :ca_port
     Puppet[:ca_port] = "321"
     terminus_class.port.should == 321
   end
 
   it "should default to :port for the port setting" do
     terminus_class.expects(:port_setting).returns nil
     Puppet[:masterport] = "543"
     terminus_class.port.should == 543
   end
 
   it 'should default to :puppet for the srv_service' do
     Puppet::Indirector::REST.srv_service.should == :puppet
   end
 
   describe "when creating an HTTP client" do
     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
       terminus.class.expects(:port).returns 321
       terminus.class.expects(:server).returns "myserver"
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       terminus.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
       terminus.class.stubs(:port).returns 321
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       terminus.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
       terminus.class.stubs(:server).returns "myserver"
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       terminus.network(@request).should == "myconn"
     end
   end
 
   describe "#find" do
     let(:http_method) { :get }
     let(:response) { mock_response(200, 'body') }
     let(:connection) { stub('mock http connection', :get => response, :verify_callback= => nil) }
     let(:request) { find_request('foo') }
 
     before :each do
       terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :find
     it_behaves_like 'a deserializing terminus method', :find
 
     describe "with a long set of parameters" do
       it "calls post on the connection with the query params in the body" do
         params = {}
         'aa'.upto('zz') do |s|
           params[s] = 'foo'
         end
 
         # The request special-cases this parameter, and it
         # won't be passed on to the server, so we remove it here
         # to avoid a failure.
         params.delete('ip')
 
         request = find_request('whoa', params)
 
         connection.expects(:post).with do |uri, body|
           body.split("&").sort == params.map {|key,value| "#{key}=#{value}"}.sort
         end.returns(mock_response(200, 'body'))
 
         terminus.find(request)
       end
     end
 
     describe "with no parameters" do
       it "calls get on the connection" do
         request = find_request('foo bar')
 
         connection.expects(:get).with('/production/test_model/foo%20bar?', anything).returns(mock_response('200', 'response body'))
 
         terminus.find(request).should == model.new('foo bar', 'response body')
       end
     end
 
     it "returns nil on 404" do
       response = mock_response('404', nil)
 
       connection.expects(:get).returns(response)
 
       terminus.find(request).should == nil
     end
 
     it 'raises no warning for a 404 (when not asked to do so)' do
       response = mock_response('404', 'this is the notfound you are looking for')
       connection.expects(:get).returns(response)
       expected_message = 'Find /production/test_model/foo? resulted in 404 with the message: this is the notfound you are looking for'
       expect{terminus.find(request)}.to_not raise_error()
     end
 
     context 'when fail_on_404 is used in request' do
       it 'raises an error for a 404 when asked to do so' do
         request = find_request('foo', :fail_on_404 => true)
         response = mock_response('404', 'this is the notfound you are looking for')
         connection.expects(:get).returns(response)
 
         expect do
           terminus.find(request)
         end.to raise_error(
           Puppet::Error,
           'Find /production/test_model/foo?fail_on_404=true resulted in 404 with the message: this is the notfound you are looking for')
       end
 
       it 'truncates the URI when it is very long' do
         request = find_request('foo', :fail_on_404 => true, :long_param => ('A' * 100) + 'B')
         response = mock_response('404', 'this is the notfound you are looking for')
         connection.expects(:get).returns(response)
 
         expect do
           terminus.find(request)
         end.to raise_error(
           Puppet::Error,
           /\/production\/test_model\/foo.*long_param=A+\.\.\..*resulted in 404 with the message/)
       end
 
       it 'does not truncate the URI when logging debug information' do
         Puppet.debug = true
         request = find_request('foo', :fail_on_404 => true, :long_param => ('A' * 100) + 'B')
         response = mock_response('404', 'this is the notfound you are looking for')
         connection.expects(:get).returns(response)
 
         expect do
           terminus.find(request)
         end.to raise_error(
           Puppet::Error,
           /\/production\/test_model\/foo.*long_param=A+B.*resulted in 404 with the message/)
       end
     end
 
     it "asks the model to deserialize the response body and sets the name on the resulting object to the find key" do
       connection.expects(:get).returns response
 
       model.expects(:convert_from).with(response['content-type'], response.body).returns(
         model.new('overwritten', 'decoded body')
       )
 
       terminus.find(request).should == model.new('foo', 'decoded body')
     end
 
     it "doesn't require the model to support name=" do
       connection.expects(:get).returns response
       instance = model.new('name', 'decoded body')
 
       model.expects(:convert_from).with(response['content-type'], response.body).returns(instance)
       instance.expects(:respond_to?).with(:name=).returns(false)
       instance.expects(:name=).never
 
       terminus.find(request).should == model.new('name', 'decoded body')
     end
 
     it "provides an Accept header containing the list of supported formats joined with commas" do
       connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(response)
 
       terminus.model.expects(:supported_formats).returns %w{supported formats}
       terminus.find(request)
     end
 
     it "adds an Accept-Encoding header" do
       terminus.expects(:add_accept_encoding).returns({"accept-encoding" => "gzip"})
 
       connection.expects(:get).with(anything, has_entry("accept-encoding" => "gzip")).returns(response)
 
       terminus.find(request)
     end
 
     it "uses only the mime-type from the content-type header when asking the model to deserialize" do
       response = mock_response('200', 'mydata', "text/plain; charset=utf-8")
       connection.expects(:get).returns(response)
 
       model.expects(:convert_from).with("text/plain", "mydata").returns "myobject"
 
       terminus.find(request).should == "myobject"
     end
 
     it "decompresses the body before passing it to the model for deserialization" do
       uncompressed_body = "Why hello there"
       compressed_body = Zlib::Deflate.deflate(uncompressed_body)
 
       response = mock_response('200', compressed_body, 'text/plain', 'deflate')
       connection.expects(:get).returns(response)
 
       model.expects(:convert_from).with("text/plain", uncompressed_body).returns "myobject"
 
       terminus.find(request).should == "myobject"
     end
   end
 
   describe "#head" do
     let(:http_method) { :head }
     let(:response) { mock_response(200, nil) }
     let(:connection) { stub('mock http connection', :head => response, :verify_callback= => nil) }
     let(:request) { head_request('foo') }
 
     before :each do
       terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :head
 
     it "returns true if there was a successful http response" do
       connection.expects(:head).returns mock_response('200', nil)
 
       terminus.head(request).should == true
     end
 
     it "returns false on a 404 response" do
       connection.expects(:head).returns mock_response('404', nil)
 
       terminus.head(request).should == false
     end
   end
 
   describe "#search" do
     let(:http_method) { :get }
     let(:response) { mock_response(200, 'data1,data2,data3') }
     let(:connection) { stub('mock http connection', :get => response, :verify_callback= => nil) }
     let(:request) { search_request('foo') }
 
     before :each do
       terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :search
     it_behaves_like 'a deserializing terminus method', :search
 
     it "should call the GET http method on a network connection" do
       connection.expects(:get).with('/production/test_models/foo', has_key('Accept')).returns mock_response(200, 'data3, data4')
 
       terminus.search(request)
     end
 
     it "returns an empty list on 404" do
       response = mock_response('404', nil)
 
       connection.expects(:get).returns(response)
 
       terminus.search(request).should == []
     end
 
     it "asks the model to deserialize the response body into multiple instances" do
       terminus.search(request).should == [model.new('', 'data1'), model.new('', 'data2'), model.new('', 'data3')]
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(mock_response(200, ''))
 
       terminus.model.expects(:supported_formats).returns %w{supported formats}
       terminus.search(request)
     end
 
     it "should return an empty array if serialization returns nil" do
       model.stubs(:convert_from_multiple).returns nil
 
       terminus.search(request).should == []
     end
   end
 
   describe "#destroy" do
     let(:http_method) { :delete }
     let(:response) { mock_response(200, 'body') }
     let(:connection) { stub('mock http connection', :delete => response, :verify_callback= => nil) }
     let(:request) { delete_request('foo') }
 
     before :each do
       terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :destroy
     it_behaves_like 'a deserializing terminus method', :destroy
 
     it "should call the DELETE http method on a network connection" do
       connection.expects(:delete).with('/production/test_model/foo', has_key('Accept')).returns(response)
 
       terminus.destroy(request)
     end
 
     it "should fail if any options are provided, since DELETE apparently does not support query options" do
       request = delete_request('foo', :one => "two", :three => "four")
 
       expect { terminus.destroy(request) }.to raise_error(ArgumentError)
     end
 
     it "should deserialize and return the http response" do
       connection.expects(:delete).returns response
 
       terminus.destroy(request).should == model.new('', 'body')
     end
 
     it "returns nil on 404" do
       response = mock_response('404', nil)
 
       connection.expects(:delete).returns(response)
 
       terminus.destroy(request).should == nil
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       connection.expects(:delete).with(anything, has_entry("Accept" => "supported, formats")).returns(response)
 
       terminus.model.expects(:supported_formats).returns %w{supported formats}
       terminus.destroy(request)
     end
   end
 
   describe "#save" do
     let(:http_method) { :put }
     let(:response) { mock_response(200, 'body') }
     let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
     let(:instance) { model.new('the thing', 'some contents') }
     let(:request) { save_request(instance.name, instance) }
 
     before :each do
       terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :save
 
     it "should call the PUT http method on a network connection" do
       connection.expects(:put).with('/production/test_model/the%20thing', anything, has_key("Content-Type")).returns response
 
       terminus.save(request)
     end
 
     it "should fail if any options are provided, since PUT apparently does not support query options" do
       request = save_request(instance.name, instance, :one => "two", :three => "four")
 
       expect { terminus.save(request) }.to raise_error(ArgumentError)
     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(anything, "serial_instance", anything).returns response
 
       terminus.save(request)
     end
 
     it "returns nil on 404" do
       response = mock_response('404', nil)
 
       connection.expects(:put).returns(response)
 
       terminus.save(request).should == nil
     end
 
     it "returns nil" do
       connection.expects(:put).returns response
 
       terminus.save(request).should be_nil
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
       connection.expects(:put).with(anything, anything, has_entry("Accept" => "supported, formats")).returns(response)
 
       instance.expects(:render).returns('')
       model.expects(:supported_formats).returns %w{supported formats}
       instance.expects(:mime).returns "supported"
 
       terminus.save(request)
     end
 
     it "should provide a Content-Type header containing the mime-type of the sent object" do
       instance.expects(:mime).returns "mime"
       connection.expects(:put).with(anything, anything, has_entry('Content-Type' => "mime")).returns(response)
 
       terminus.save(request)
     end
   end
 
   context 'dealing with SRV settings' do
     [
       :destroy,
       :find,
       :head,
       :save,
       :search
     ].each do |method|
       it "##{method} passes the SRV service, and fall-back server & port to the request's do_request method" do
         request = Puppet::Indirector::Request.new(:indirection, method, 'key', nil)
         stub_response = mock_response('200', 'body')
 
         request.expects(:do_request).with(terminus.class.srv_service, terminus.class.server, terminus.class.port).returns(stub_response)
 
         terminus.send(method, request)
       end
     end
   end
 end
diff --git a/spec/unit/network/http/rack/rest_spec.rb b/spec/unit/network/http/rack/rest_spec.rb
index 8af253c5d..764a0bf56 100755
--- a/spec/unit/network/http/rack/rest_spec.rb
+++ b/spec/unit/network/http/rack/rest_spec.rb
@@ -1,318 +1,318 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 require 'puppet/network/http/rack/rest'
 
 describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
   it "should include the Puppet::Network::HTTP::Handler module" do
     Puppet::Network::HTTP::RackREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
   end
 
   describe "when serving a request" do
     before :all do
       @model_class = stub('indirected model class')
       Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
     end
 
     before :each do
       @response = Rack::Response.new
       @handler = Puppet::Network::HTTP::RackREST.new(:handler => :foo)
     end
 
     def mk_req(uri, opts = {})
       env = Rack::MockRequest.env_for(uri, opts)
       Rack::Request.new(env)
     end
 
     let(:minimal_certificate) do
       key = OpenSSL::PKey::RSA.new(512)
       signer = Puppet::SSL::CertificateSigner.new
       cert = OpenSSL::X509::Certificate.new
       cert.version = 2
       cert.serial = 0
       cert.not_before = Time.now
       cert.not_after = Time.now + 3600
       cert.public_key = key
       cert.subject = OpenSSL::X509::Name.parse("/CN=testing")
       signer.sign(cert, key)
       cert
     end
 
     describe "#headers" do
       it "should return the headers (parsed from env with prefix 'HTTP_')" do
         req = mk_req('/', {'HTTP_Accept' => 'myaccept',
                            'HTTP_X_Custom_Header' => 'mycustom',
                            'NOT_HTTP_foo' => 'not an http header'})
         @handler.headers(req).should == {"accept" => 'myaccept',
                                          "x-custom-header" => 'mycustom',
                                          "content-type" => nil }
       end
     end
 
     describe "and using the HTTP Handler interface" do
       it "should return the CONTENT_TYPE parameter as the content type header" do
         req = mk_req('/', 'CONTENT_TYPE' => 'mycontent')
         @handler.headers(req)['content-type'].should == "mycontent"
       end
 
       it "should use the REQUEST_METHOD as the http method" do
         req = mk_req('/', :method => 'MYMETHOD')
         @handler.http_method(req).should == "MYMETHOD"
       end
 
       it "should return the request path as the path" do
         req = mk_req('/foo/bar')
         @handler.path(req).should == "/foo/bar"
       end
 
       it "should return the request body as the body" do
         req = mk_req('/foo/bar', :input => 'mybody')
         @handler.body(req).should == "mybody"
       end
 
       it "should return the an Puppet::SSL::Certificate instance as the client_cert" do
         req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => minimal_certificate.to_pem)
         expect(@handler.client_cert(req).content.to_pem).to eq(minimal_certificate.to_pem)
       end
 
       it "returns nil when SSL_CLIENT_CERT is empty" do
         req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => '')
 
         @handler.client_cert(req).should be_nil
       end
 
       it "should set the response's content-type header when setting the content type" do
         @header = mock 'header'
         @response.expects(:header).returns @header
         @header.expects(:[]=).with('Content-Type', "mytype")
 
         @handler.set_content_type(@response, "mytype")
       end
 
       it "should set the status and write the body when setting the response for a request" do
         @response.expects(:status=).with(400)
         @response.expects(:write).with("mybody")
 
         @handler.set_response(@response, "mybody", 400)
       end
 
       describe "when result is a File" do
         before :each do
           stat = stub 'stat', :size => 100
           @file = stub 'file', :stat => stat, :path => "/tmp/path"
           @file.stubs(:is_a?).with(File).returns(true)
         end
 
         it "should set the Content-Length header as a string" do
           @response.expects(:[]=).with("Content-Length", '100')
 
           @handler.set_response(@response, @file, 200)
         end
 
         it "should return a RackFile adapter as body" do
           @response.expects(:body=).with { |val| val.is_a?(Puppet::Network::HTTP::RackREST::RackFile) }
 
           @handler.set_response(@response, @file, 200)
         end
       end
 
       it "should ensure the body has been read on success" do
         req = mk_req('/production/report/foo', :method => 'PUT')
         req.body.expects(:read).at_least_once
 
         Puppet::Transaction::Report.stubs(:save)
 
         @handler.process(req, @response)
       end
 
       it "should ensure the body has been partially read on failure" do
         req = mk_req('/production/report/foo')
         req.body.expects(:read).with(1)
 
         @handler.stubs(:headers).raises(Exception)
 
         @handler.process(req, @response)
       end
     end
 
     describe "and determining the request parameters" do
       it "should include the HTTP request parameters, with the keys as symbols" do
         req = mk_req('/?foo=baz&bar=xyzzy')
         result = @handler.params(req)
         result[:foo].should == "baz"
         result[:bar].should == "xyzzy"
       end
 
       it "should return multi-values params as an array of the values" do
         req = mk_req('/?foo=baz&foo=xyzzy')
         result = @handler.params(req)
         result[:foo].should == ["baz", "xyzzy"]
       end
 
       it "should return parameters from the POST body" do
         req = mk_req("/", :method => 'POST', :input => 'foo=baz&bar=xyzzy')
         result = @handler.params(req)
         result[:foo].should == "baz"
         result[:bar].should == "xyzzy"
       end
 
       it "should not return multi-valued params in a POST body as an array of values" do
         req = mk_req("/", :method => 'POST', :input => 'foo=baz&foo=xyzzy')
         result = @handler.params(req)
         result[:foo].should be_one_of("baz", "xyzzy")
       end
 
       it "should CGI-decode the HTTP parameters" do
         encoding = CGI.escape("foo bar")
         req = mk_req("/?foo=#{encoding}")
         result = @handler.params(req)
         result[:foo].should == "foo bar"
       end
 
       it "should convert the string 'true' to the boolean" do
         req = mk_req("/?foo=true")
         result = @handler.params(req)
         result[:foo].should be_true
       end
 
       it "should convert the string 'false' to the boolean" do
         req = mk_req("/?foo=false")
         result = @handler.params(req)
         result[:foo].should be_false
       end
 
       it "should convert integer arguments to Integers" do
         req = mk_req("/?foo=15")
         result = @handler.params(req)
         result[:foo].should == 15
       end
 
       it "should convert floating point arguments to Floats" do
         req = mk_req("/?foo=1.5")
         result = @handler.params(req)
         result[:foo].should == 1.5
       end
 
       it "should treat YAML encoded parameters like it was any string" do
         escaping = CGI.escape(YAML.dump(%w{one two}))
         req = mk_req("/?foo=#{escaping}")
-        @handler.params(req)[:foo].should == "--- \n  - one\n  - two"
+        @handler.params(req)[:foo].should == "---\n- one\n- two\n"
       end
 
       it "should not allow the client to set the node via the query string" do
         req = mk_req("/?node=foo")
         @handler.params(req)[:node].should be_nil
       end
 
       it "should not allow the client to set the IP address via the query string" do
         req = mk_req("/?ip=foo")
         @handler.params(req)[:ip].should be_nil
       end
 
       it "should pass the client's ip address to model find" do
         req = mk_req("/", 'REMOTE_ADDR' => 'ipaddress')
         @handler.params(req)[:ip].should == "ipaddress"
       end
 
       it "should set 'authenticated' to false if no certificate is present" do
         req = mk_req('/')
         @handler.params(req)[:authenticated].should be_false
       end
     end
 
     describe "with pre-validated certificates" do
       it "should retrieve the hostname by finding the CN given in :ssl_client_header, in the format returned by Apache (RFC2253)" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => "O=Foo\\, Inc,CN=host.domain.com")
         @handler.params(req)[:node].should == "host.domain.com"
       end
 
       it "should retrieve the hostname by finding the CN given in :ssl_client_header, in the format returned by nginx" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => "/CN=host.domain.com")
         @handler.params(req)[:node].should == "host.domain.com"
       end
 
       it "should retrieve the hostname by finding the CN given in :ssl_client_header, ignoring other fields" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => 'ST=Denial,CN=host.domain.com,O=Domain\\, Inc.')
         @handler.params(req)[:node].should == "host.domain.com"
       end
 
       it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
         Puppet[:ssl_client_header] = "certheader"
         Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_true
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
         Puppet[:ssl_client_header] = "certheader"
         Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => "whatever", "certheader" => "CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_false
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
         Puppet[:ssl_client_header] = "certheader"
         Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => nil, "certheader" => "CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_false
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => nil)
         @handler.expects(:resolve_node).returns("host.domain.com")
         @handler.params(req)[:node].should == "host.domain.com"
       end
 
       it "should resolve the node name with an ip address look-up if a certificate without a CN is present" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => "O=no CN")
         @handler.expects(:resolve_node).returns("host.domain.com")
         @handler.params(req)[:node].should == "host.domain.com"
       end
 
       it "should not allow authentication via the verify header if there is no CN available" do
         Puppet[:ssl_client_header] = "dn_header"
         Puppet[:ssl_client_verify_header] = "verify_header"
         req = mk_req('/', "dn_header" => "O=no CN", "verify_header" => 'SUCCESS')
 
         @handler.expects(:resolve_node).returns("host.domain.com")
 
         @handler.params(req)[:authenticated].should be_false
       end
     end
   end
 end
 
 describe Puppet::Network::HTTP::RackREST::RackFile do
   before(:each) do
     stat = stub 'stat', :size => 100
     @file = stub 'file', :stat => stat, :path => "/tmp/path"
     @rackfile = Puppet::Network::HTTP::RackREST::RackFile.new(@file)
   end
 
   it "should have an each method" do
     @rackfile.should be_respond_to(:each)
   end
 
   it "should yield file chunks by chunks" do
     @file.expects(:read).times(3).with(8192).returns("1", "2", nil)
     i = 1
     @rackfile.each do |chunk|
       chunk.to_i.should == i
       i += 1
     end
   end
 
   it "should have a close method" do
     @rackfile.should be_respond_to(:close)
   end
 
   it "should delegate close to File close" do
     @file.expects(:close)
     @rackfile.close
   end
 end
diff --git a/spec/unit/network/http/webrick/rest_spec.rb b/spec/unit/network/http/webrick/rest_spec.rb
index f44faf6e7..1f44c3391 100755
--- a/spec/unit/network/http/webrick/rest_spec.rb
+++ b/spec/unit/network/http/webrick/rest_spec.rb
@@ -1,220 +1,220 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'webrick'
 require 'puppet/network/http/webrick/rest'
 
 describe Puppet::Network::HTTP::WEBrickREST do
   it "should include the Puppet::Network::HTTP::Handler module" do
     Puppet::Network::HTTP::WEBrickREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
   end
 
   describe "when receiving a request" do
     before do
       @request     = stub('webrick http request', :query => {}, :peeraddr => %w{eh boo host ip}, :client_cert => nil)
       @response    = mock('webrick http response')
       @model_class = stub('indirected model class')
       @webrick     = stub('webrick http server', :mount => true, :[] => {})
       Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
       @handler = Puppet::Network::HTTP::WEBrickREST.new(@webrick)
     end
 
     it "should delegate its :service method to its :process method" do
       @handler.expects(:process).with(@request, @response).returns "stuff"
       @handler.service(@request, @response).should == "stuff"
     end
 
     describe "#headers" do
       let(:fake_request) { {"Foo" => "bar", "BAZ" => "bam" } }
 
       it "should iterate over the request object using #each" do
         fake_request.expects(:each)
         @handler.headers(fake_request)
       end
 
       it "should return a hash with downcased header names" do
         result = @handler.headers(fake_request)
         result.should == fake_request.inject({}) { |m,(k,v)| m[k.downcase] = v; m }
       end
     end
 
     describe "when using the Handler interface" do
       it "should use the request method as the http method" do
         @request.expects(:request_method).returns "FOO"
         @handler.http_method(@request).should == "FOO"
       end
 
       it "should return the request path as the path" do
         @request.expects(:path).returns "/foo/bar"
         @handler.path(@request).should == "/foo/bar"
       end
 
       it "should return the request body as the body" do
         @request.expects(:body).returns "my body"
         @handler.body(@request).should == "my body"
       end
 
       it "should set the response's 'content-type' header when setting the content type" do
         @response.expects(:[]=).with("content-type", "text/html")
         @handler.set_content_type(@response, "text/html")
       end
 
       it "should set the status and body on the response when setting the response for a successful query" do
         @response.expects(:status=).with 200
         @response.expects(:body=).with "mybody"
 
         @handler.set_response(@response, "mybody", 200)
       end
 
       it "serves a file" do
         stat = stub 'stat', :size => 100
         @file = stub 'file', :stat => stat, :path => "/tmp/path"
         @file.stubs(:is_a?).with(File).returns(true)
 
         @response.expects(:[]=).with('content-length', 100)
         @response.expects(:status=).with 200
         @response.expects(:body=).with @file
 
         @handler.set_response(@response, @file, 200)
       end
 
       it "should set the status and message on the response when setting the response for a failed query" do
         @response.expects(:status=).with 400
         @response.expects(:body=).with "mybody"
 
         @handler.set_response(@response, "mybody", 400)
       end
     end
 
     describe "and determining the request parameters" do
       def query_of(options)
         request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil, options)
         WEBrick::HTTPUtils.parse_query(request.query_string.sub(/^\?/, ''))
       end
 
       def a_request_querying(query_data)
         @request.expects(:query).returns(query_of(query_data))
         @request
       end
 
       def certificate_with_subject(subj)
         cert = OpenSSL::X509::Certificate.new
         cert.subject = OpenSSL::X509::Name.parse(subj)
         cert
       end
 
       it "has no parameters when there is no query string" do
         only_server_side_information = [:authenticated, :ip, :node]
         @request.stubs(:query).returns(nil)
 
         result = @handler.params(@request)
 
         result.keys.sort.should == only_server_side_information
       end
 
       it "should include the HTTP request parameters, with the keys as symbols" do
         request = a_request_querying("foo" => "baz", "bar" => "xyzzy")
         result = @handler.params(request)
 
         result[:foo].should == "baz"
         result[:bar].should == "xyzzy"
       end
 
       it "should handle parameters with no value" do
         request = a_request_querying('foo' => "")
 
         result = @handler.params(request)
 
         result[:foo].should == ""
       end
 
       it "should convert the string 'true' to the boolean" do
         request = a_request_querying('foo' => "true")
 
         result = @handler.params(request)
 
         result[:foo].should == true
       end
 
       it "should convert the string 'false' to the boolean" do
         request = a_request_querying('foo' => "false")
 
         result = @handler.params(request)
 
         result[:foo].should == false
       end
 
       it "should reconstruct arrays" do
         request = a_request_querying('foo' => ["a", "b", "c"])
 
         result = @handler.params(request)
 
         result[:foo].should == ["a", "b", "c"]
       end
 
       it "should convert values inside arrays into primitive types" do
         request = a_request_querying('foo' => ["true", "false", "1", "1.2"])
 
         result = @handler.params(request)
 
         result[:foo].should == [true, false, 1, 1.2]
       end
 
       it "should treat YAML-load values that are YAML-encoded as any other String" do
         request = a_request_querying('foo' => YAML.dump(%w{one two}))
-        @handler.params(request)[:foo].should == "--- \n  - one\n  - two"
+        @handler.params(request)[:foo].should == "---\n- one\n- two\n"
       end
 
       it "should not allow clients to set the node via the request parameters" do
         request = a_request_querying("node" => "foo")
         @handler.stubs(:resolve_node)
 
         @handler.params(request)[:node].should be_nil
       end
 
       it "should not allow clients to set the IP via the request parameters" do
         request = a_request_querying("ip" => "foo")
 
         @handler.params(request)[:ip].should_not == "foo"
       end
 
       it "should pass the client's ip address to model find" do
         @request.stubs(:peeraddr).returns(%w{noidea dunno hostname ipaddress})
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should set 'authenticated' to true if a certificate is present" do
         cert = stub 'cert', :subject => [%w{CN host.domain.com}]
         @request.stubs(:client_cert).returns cert
         @handler.params(@request)[:authenticated].should be_true
       end
 
       it "should set 'authenticated' to false if no certificate is present" do
         @request.stubs(:client_cert).returns nil
         @handler.params(@request)[:authenticated].should be_false
       end
 
       it "should pass the client's certificate name to model method if a certificate is present" do
         @request.stubs(:client_cert).returns(certificate_with_subject("/CN=host.domain.com"))
 
         @handler.params(@request)[:node].should == "host.domain.com"
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         @request.stubs(:client_cert).returns nil
 
         @handler.expects(:resolve_node).returns(:resolved_node)
 
         @handler.params(@request)[:node].should == :resolved_node
       end
 
       it "should resolve the node name with an ip address look-up if CN parsing fails" do
         @request.stubs(:client_cert).returns(certificate_with_subject("/C=company"))
 
         @handler.expects(:resolve_node).returns(:resolved_node)
 
         @handler.params(@request)[:node].should == :resolved_node
       end
     end
   end
 end
diff --git a/spec/unit/node/environment_spec.rb b/spec/unit/node/environment_spec.rb
index 3c4065871..d4e7e0fc4 100755
--- a/spec/unit/node/environment_spec.rb
+++ b/spec/unit/node/environment_spec.rb
@@ -1,600 +1,604 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'tmpdir'
 
 require 'puppet/node/environment'
 require 'puppet/util/execution'
 require 'puppet_spec/modules'
 require 'puppet/parser/parser_factory'
 
 describe Puppet::Node::Environment do
   let(:env) { Puppet::Node::Environment.new("testing") }
 
   include PuppetSpec::Files
   after do
     Puppet::Node::Environment.clear
   end
 
   shared_examples_for 'the environment' do
+    it "should convert an environment to string when converting to YAML" do
+      env.to_yaml.should match(/--- testing/)
+    end
+
     it "should use the filetimeout for the ttl for the module list" do
       Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
     end
 
     it "should use the default environment if no name is provided while initializing an environment" do
       Puppet[:environment] = "one"
       Puppet::Node::Environment.new.name.should == :one
     end
 
     it "should treat environment instances as singletons" do
       Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one"))
     end
 
     it "should treat an environment specified as names or strings as equivalent" do
       Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one"))
     end
 
     it "should return its name when converted to a string" do
       Puppet::Node::Environment.new(:one).to_s.should == "one"
     end
 
     it "should just return any provided environment if an environment is provided as the name" do
       one = Puppet::Node::Environment.new(:one)
       Puppet::Node::Environment.new(one).should equal(one)
     end
 
     describe "equality" do
       it "works as a hash key" do
         base = Puppet::Node::Environment.create(:first, ["modules"], "manifests")
         same = Puppet::Node::Environment.create(:first, ["modules"], "manifests")
         different = Puppet::Node::Environment.create(:first, ["different"], "manifests")
         hash = {}
 
         hash[base] = "base env"
         hash[same] = "same env"
         hash[different] = "different env"
 
         expect(hash[base]).to eq("same env")
         expect(hash[different]).to eq("different env")
         expect(hash).to have(2).item
       end
 
       it "is equal when name, modules, and manifests are the same" do
         base = Puppet::Node::Environment.create(:base, ["modules"], "manifests")
         different_name = Puppet::Node::Environment.create(:different, base.full_modulepath, base.manifest)
 
         expect(base).to_not eq("not an environment")
 
         expect(base).to eq(base)
         expect(base.hash).to eq(base.hash)
 
         expect(base.override_with(:modulepath => ["different"])).to_not eq(base)
         expect(base.override_with(:modulepath => ["different"]).hash).to_not eq(base.hash)
 
         expect(base.override_with(:manifest => "different")).to_not eq(base)
         expect(base.override_with(:manifest => "different").hash).to_not eq(base.hash)
 
         expect(different_name).to_not eq(base)
         expect(different_name.hash).to_not eq(base.hash)
       end
     end
 
     describe "overriding an existing environment" do
       let(:original_path) { [tmpdir('original')] }
       let(:new_path) { [tmpdir('new')] }
       let(:environment) { Puppet::Node::Environment.create(:overridden, original_path, 'orig.pp', '/config/script') }
 
       it "overrides modulepath" do
         overridden = environment.override_with(:modulepath => new_path)
         expect(overridden).to_not be_equal(environment)
         expect(overridden.name).to eq(:overridden)
         expect(overridden.manifest).to eq(File.expand_path('orig.pp'))
         expect(overridden.modulepath).to eq(new_path)
         expect(overridden.config_version).to eq('/config/script')
       end
 
       it "overrides manifest" do
         overridden = environment.override_with(:manifest => 'new.pp')
         expect(overridden).to_not be_equal(environment)
         expect(overridden.name).to eq(:overridden)
         expect(overridden.manifest).to eq(File.expand_path('new.pp'))
         expect(overridden.modulepath).to eq(original_path)
         expect(overridden.config_version).to eq('/config/script')
       end
 
       it "overrides config_version" do
         overridden = environment.override_with(:config_version => '/new/script')
         expect(overridden).to_not be_equal(environment)
         expect(overridden.name).to eq(:overridden)
         expect(overridden.manifest).to eq(File.expand_path('orig.pp'))
         expect(overridden.modulepath).to eq(original_path)
         expect(overridden.config_version).to eq('/new/script')
       end
     end
 
     describe "watching a file" do
       let(:filename) { "filename" }
 
       it "accepts a File" do
         file = tmpfile(filename)
         env.known_resource_types.expects(:watch_file).with(file.to_s)
         env.watch_file(file)
       end
 
       it "accepts a String" do
         env.known_resource_types.expects(:watch_file).with(filename)
         env.watch_file(filename)
       end
     end
 
     describe "when managing known resource types" do
       before do
         @collection = Puppet::Resource::TypeCollection.new(env)
         env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       end
 
       it "should create a resource type collection if none exists" do
         Puppet::Resource::TypeCollection.expects(:new).with(env).returns @collection
         env.known_resource_types.should equal(@collection)
       end
 
       it "should reuse any existing resource type collection" do
         env.known_resource_types.should equal(env.known_resource_types)
       end
 
       it "should perform the initial import when creating a new collection" do
         env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
         env.known_resource_types
       end
 
       it "should return the same collection even if stale if it's the same thread" do
         Puppet::Resource::TypeCollection.stubs(:new).returns @collection
         env.known_resource_types.stubs(:stale?).returns true
 
         env.known_resource_types.should equal(@collection)
       end
 
       it "should generate a new TypeCollection if the current one requires reparsing" do
         old_type_collection = env.known_resource_types
         old_type_collection.stubs(:require_reparse?).returns true
 
         env.check_for_reparse
 
         new_type_collection = env.known_resource_types
         new_type_collection.should be_a Puppet::Resource::TypeCollection
         new_type_collection.should_not equal(old_type_collection)
       end
     end
 
     it "should validate the modulepath directories" do
       real_file = tmpdir('moduledir')
       path = %W[/one /two #{real_file}].join(File::PATH_SEPARATOR)
 
       Puppet[:modulepath] = path
 
       env.modulepath.should == [real_file]
     end
 
     it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
       first_puppetlib = tmpdir('puppetlib1')
       second_puppetlib = tmpdir('puppetlib2')
       first_moduledir = tmpdir('moduledir1')
       second_moduledir = tmpdir('moduledir2')
       Puppet::Util.withenv("PUPPETLIB" => [first_puppetlib, second_puppetlib].join(File::PATH_SEPARATOR)) do
         Puppet[:modulepath] = [first_moduledir, second_moduledir].join(File::PATH_SEPARATOR)
 
         env.modulepath.should == [first_puppetlib, second_puppetlib, first_moduledir, second_moduledir]
       end
     end
 
     it "does not register validation_errors when not using directory environments" do
       expect(Puppet::Node::Environment.create(:directory, [], '/some/non/default/manifest.pp').validation_errors).to be_empty
     end
 
     describe "when operating in the context of directory environments" do
       before(:each) do
         Puppet[:environmentpath] = "$confdir/environments"
         Puppet[:default_manifest] = "/default/manifests/site.pp"
       end
 
       it "has no validation errors when disable_per_environment_manifest is false" do
         expect(Puppet::Node::Environment.create(:directory, [], '/some/non/default/manifest.pp').validation_errors).to be_empty
       end
 
       context "when disable_per_environment_manifest is true" do
         let(:config) { mock('config') }
         let(:global_modulepath) { ["/global/modulepath"] }
         let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, global_modulepath) }
 
         before(:each) do
           Puppet[:disable_per_environment_manifest] = true
         end
 
         def assert_manifest_conflict(expectation, envconf_manifest_value)
           config.expects(:setting).with(:manifest).returns(
             mock('setting', :value => envconf_manifest_value)
           )
           environment = Puppet::Node::Environment.create(:directory, [], '/default/manifests/site.pp')
           loader = Puppet::Environments::Static.new(environment)
           loader.stubs(:get_conf).returns(envconf)
 
           Puppet.override(:environments => loader) do
             if expectation
               expect(environment.validation_errors).to have_matching_element(/The 'disable_per_environment_manifest' setting is true.*and the.*environment.*conflicts/)
             else
               expect(environment.validation_errors).to be_empty
             end
           end
         end
 
         it "has conflicting_manifest_settings when environment.conf manifest was set" do
           assert_manifest_conflict(true, '/some/envconf/manifest/site.pp')
         end
 
         it "does not have conflicting_manifest_settings when environment.conf manifest is empty" do
           assert_manifest_conflict(false, '')
         end
 
         it "does not have conflicting_manifest_settings when environment.conf manifest is nil" do
           assert_manifest_conflict(false, nil)
         end
 
         it "does not have conflicting_manifest_settings when environment.conf manifest is an exact, uninterpolated match of default_manifest" do
           assert_manifest_conflict(false, '/default/manifests/site.pp')
         end
       end
     end
 
     describe "when modeling a specific environment" do
       it "should have a method for returning the environment name" do
         Puppet::Node::Environment.new("testing").name.should == :testing
       end
 
       it "should provide an array-like accessor method for returning any environment-specific setting" do
         env.should respond_to(:[])
       end
 
       it "obtains its core values from the puppet settings instance as a legacy env" do
         Puppet.settings.parse_config(<<-CONF)
         [testing]
         manifest = /some/manifest
         modulepath = /some/modulepath
         config_version = /some/script
         CONF
 
         env = Puppet::Node::Environment.new("testing")
         expect(env.full_modulepath).to eq([File.expand_path('/some/modulepath')])
         expect(env.manifest).to eq(File.expand_path('/some/manifest'))
         expect(env.config_version).to eq('/some/script')
       end
 
       it "should ask the Puppet settings instance for the setting qualified with the environment name" do
         Puppet.settings.parse_config(<<-CONF)
         [testing]
         server = myval
         CONF
 
         env[:server].should == "myval"
       end
 
       it "should be able to return an individual module that exists in its module path" do
         env.stubs(:modules).returns [Puppet::Module.new('one', "/one", mock("env"))]
 
         mod = env.module('one')
         mod.should be_a(Puppet::Module)
         mod.name.should == 'one'
       end
 
       it "should not return a module if the module doesn't exist" do
         env.stubs(:modules).returns [Puppet::Module.new('one', "/one", mock("env"))]
 
         env.module('two').should be_nil
       end
 
       it "should return nil if asked for a module that does not exist in its path" do
         modpath = tmpdir('modpath')
         env = Puppet::Node::Environment.create(:testing, [modpath])
 
         env.module("one").should be_nil
       end
 
       describe "module data" do
         before do
           dir = tmpdir("deep_path")
 
           @first = File.join(dir, "first")
           @second = File.join(dir, "second")
           Puppet[:modulepath] = "#{@first}#{File::PATH_SEPARATOR}#{@second}"
 
           FileUtils.mkdir_p(@first)
           FileUtils.mkdir_p(@second)
         end
 
         describe "#modules_by_path" do
           it "should return an empty list if there are no modules" do
             env.modules_by_path.should == {
               @first  => [],
               @second => []
             }
           end
 
           it "should include modules even if they exist in multiple dirs in the modulepath" do
             modpath1 = File.join(@first, "foo")
             FileUtils.mkdir_p(modpath1)
             modpath2 = File.join(@second, "foo")
             FileUtils.mkdir_p(modpath2)
 
             env.modules_by_path.should == {
               @first  => [Puppet::Module.new('foo', modpath1, env)],
               @second => [Puppet::Module.new('foo', modpath2, env)]
             }
           end
 
           it "should ignore modules with invalid names" do
             PuppetSpec::Modules.generate_files('foo', @first)
             PuppetSpec::Modules.generate_files('foo2', @first)
             PuppetSpec::Modules.generate_files('foo-bar', @first)
             PuppetSpec::Modules.generate_files('foo_bar', @first)
             PuppetSpec::Modules.generate_files('foo=bar', @first)
             PuppetSpec::Modules.generate_files('foo bar', @first)
             PuppetSpec::Modules.generate_files('foo.bar', @first)
             PuppetSpec::Modules.generate_files('-foo', @first)
             PuppetSpec::Modules.generate_files('foo-', @first)
             PuppetSpec::Modules.generate_files('foo--bar', @first)
 
             env.modules_by_path[@first].collect{|mod| mod.name}.sort.should == %w{foo foo-bar foo2 foo_bar}
           end
 
         end
 
         describe "#module_requirements" do
           it "should return a list of what modules depend on other modules" do
             PuppetSpec::Modules.create(
               'foo',
               @first,
               :metadata => {
                 :author       => 'puppetlabs',
                 :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => ">= 1.0.0" }]
               }
             )
             PuppetSpec::Modules.create(
               'bar',
               @second,
               :metadata => {
                 :author       => 'puppetlabs',
                 :dependencies => [{ 'name' => 'puppetlabs/foo', "version_requirement" => "<= 2.0.0" }]
               }
             )
             PuppetSpec::Modules.create(
               'baz',
               @first,
               :metadata => {
                 :author       => 'puppetlabs',
                 :dependencies => [{ 'name' => 'puppetlabs-bar', "version_requirement" => "3.0.0" }]
               }
             )
             PuppetSpec::Modules.create(
               'alpha',
               @first,
               :metadata => {
                 :author       => 'puppetlabs',
                 :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => "~3.0.0" }]
               }
             )
 
             env.module_requirements.should == {
               'puppetlabs/alpha' => [],
               'puppetlabs/foo' => [
                 {
                   "name"    => "puppetlabs/bar",
                   "version" => "9.9.9",
                   "version_requirement" => "<= 2.0.0"
                 }
               ],
               'puppetlabs/bar' => [
                 {
                   "name"    => "puppetlabs/alpha",
                   "version" => "9.9.9",
                   "version_requirement" => "~3.0.0"
                 },
                 {
                   "name"    => "puppetlabs/baz",
                   "version" => "9.9.9",
                   "version_requirement" => "3.0.0"
                 },
                 {
                   "name"    => "puppetlabs/foo",
                   "version" => "9.9.9",
                   "version_requirement" => ">= 1.0.0"
                 }
               ],
               'puppetlabs/baz' => []
             }
           end
         end
 
         describe ".module_by_forge_name" do
           it "should find modules by forge_name" do
             mod = PuppetSpec::Modules.create(
               'baz',
               @first,
               :metadata => {:author => 'puppetlabs'},
               :environment => env
             )
             env.module_by_forge_name('puppetlabs/baz').should == mod
           end
 
           it "should not find modules with same name by the wrong author" do
             mod = PuppetSpec::Modules.create(
               'baz',
               @first,
               :metadata => {:author => 'sneakylabs'},
               :environment => env
             )
             env.module_by_forge_name('puppetlabs/baz').should == nil
           end
 
           it "should return nil when the module can't be found" do
             env.module_by_forge_name('ima/nothere').should be_nil
           end
         end
 
         describe ".modules" do
           it "should return an empty list if there are no modules" do
             env.modules.should == []
           end
 
           it "should return a module named for every directory in each module path" do
             %w{foo bar}.each do |mod_name|
               PuppetSpec::Modules.generate_files(mod_name, @first)
             end
             %w{bee baz}.each do |mod_name|
               PuppetSpec::Modules.generate_files(mod_name, @second)
             end
             env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
           end
 
           it "should remove duplicates" do
             PuppetSpec::Modules.generate_files('foo', @first)
             PuppetSpec::Modules.generate_files('foo', @second)
 
             env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
           end
 
           it "should ignore modules with invalid names" do
             PuppetSpec::Modules.generate_files('foo', @first)
             PuppetSpec::Modules.generate_files('foo2', @first)
             PuppetSpec::Modules.generate_files('foo-bar', @first)
             PuppetSpec::Modules.generate_files('foo_bar', @first)
             PuppetSpec::Modules.generate_files('foo=bar', @first)
             PuppetSpec::Modules.generate_files('foo bar', @first)
 
             env.modules.collect{|mod| mod.name}.sort.should == %w{foo foo-bar foo2 foo_bar}
           end
 
           it "should create modules with the correct environment" do
             PuppetSpec::Modules.generate_files('foo', @first)
 
             env.modules.each {|mod| mod.environment.should == env }
           end
 
           it "should log an exception if a module contains invalid metadata" do
             PuppetSpec::Modules.generate_files(
               'foo',
               @first,
               :metadata => {
                 :author       => 'puppetlabs'
                 # missing source, version, etc
               }
             )
 
             Puppet.expects(:log_exception).with(is_a(Puppet::Module::MissingMetadata))
 
             env.modules
           end
         end
       end
     end
 
     describe "when performing initial import" do
       def parser_and_environment(name)
         env = Puppet::Node::Environment.new(name)
         parser = Puppet::Parser::ParserFactory.parser(env)
         Puppet::Parser::ParserFactory.stubs(:parser).returns(parser)
 
         [parser, env]
       end
 
       it "should set the parser's string to the 'code' setting and parse if code is available" do
         Puppet[:code] = "my code"
         parser, env = parser_and_environment('testing')
 
         parser.expects(:string=).with "my code"
         parser.expects(:parse)
 
         env.instance_eval { perform_initial_import }
       end
 
       it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
         filename = tmpfile('myfile')
         Puppet[:manifest] = filename
         parser, env = parser_and_environment('testing')
 
         parser.expects(:file=).with filename
         parser.expects(:parse)
 
         env.instance_eval { perform_initial_import }
       end
 
       it "should pass the manifest file to the parser even if it does not exist on disk" do
         filename = tmpfile('myfile')
         Puppet[:code] = ""
         Puppet[:manifest] = filename
         parser, env = parser_and_environment('testing')
 
         parser.expects(:file=).with(filename).once
         parser.expects(:parse).once
 
         env.instance_eval { perform_initial_import }
       end
 
       it "should fail helpfully if there is an error importing" do
         Puppet::FileSystem.stubs(:exist?).returns true
         parser, env = parser_and_environment('testing')
 
         parser.expects(:file=).once
         parser.expects(:parse).raises ArgumentError
 
         expect do
           env.known_resource_types
         end.to raise_error(Puppet::Error)
       end
 
       it "should not do anything if the ignore_import settings is set" do
         Puppet[:ignoreimport] = true
         parser, env = parser_and_environment('testing')
 
         parser.expects(:string=).never
         parser.expects(:file=).never
         parser.expects(:parse).never
 
         env.instance_eval { perform_initial_import }
       end
 
       it "should mark the type collection as needing a reparse when there is an error parsing" do
         parser, env = parser_and_environment('testing')
 
         parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
 
         expect do
           env.known_resource_types
         end.to raise_error(Puppet::Error, /Syntax error at .../)
         env.known_resource_types.require_reparse?.should be_true
       end
     end
   end
 
   describe 'with classic parser' do
     before :each do
       Puppet[:parser] = 'current'
     end
     it_behaves_like 'the environment'
   end
 
   describe 'with future parser' do
     before :each do
       Puppet[:parser] = 'future'
     end
     it_behaves_like 'the environment'
   end
 
   describe '#current' do
     it 'should return the current context' do
       env = Puppet::Node::Environment.new(:test)
       Puppet::Context.any_instance.expects(:lookup).with(:current_environment).returns(env)
       Puppet.expects(:deprecation_warning).once
       Puppet::Node::Environment.current.should equal(env)
     end
   end
 
 end
diff --git a/spec/unit/util/zaml_spec.rb b/spec/unit/util/zaml_spec.rb
deleted file mode 100755
index 9a3485049..000000000
--- a/spec/unit/util/zaml_spec.rb
+++ /dev/null
@@ -1,308 +0,0 @@
-#! /usr/bin/env ruby
-# encoding: UTF-8
-#
-# The above encoding line is a magic comment to set the default source encoding
-# of this file for the Ruby interpreter.  It must be on the first or second
-# line of the file if an interpreter is in use.  In Ruby 1.9 and later, the
-# source encoding determines the encoding of String and Regexp objects created
-# from this source file.  This explicit encoding is important because otherwise
-# Ruby will pick an encoding based on LANG or LC_CTYPE environment variables.
-# These may be different from site to site so it's important for us to
-# establish a consistent behavior.  For more information on M17n please see:
-# http://links.puppetlabs.com/understanding_m17n
-
-require 'spec_helper'
-
-require 'puppet/util/monkey_patches'
-
-describe "Pure ruby yaml implementation" do
-  RSpec::Matchers.define :round_trip_through_yaml do
-    match do |object|
-      YAML.load(object.to_yaml) == object
-    end
-  end
-
-  RSpec::Matchers.define :be_equivalent_to do |expected_yaml|
-    match do |object|
-      object.to_yaml == expected_yaml and YAML.load(expected_yaml) == object
-    end
-
-    failure_message_for_should do |object|
-      if object.to_yaml != expected_yaml
-        "#{object} serialized to #{object.to_yaml}"
-      else
-        "#{expected_yaml} deserialized as #{YAML.load(expected_yaml)}"
-      end
-    end
-  end
-
-  {
-    7            => "--- 7",
-    3.14159      => "--- 3.14159",
-    "3.14159"    => '--- "3.14159"',
-    "+3.14159"   => '--- "+3.14159"',
-    "0x123abc"   => '--- "0x123abc"',
-    "-0x123abc"  => '--- "-0x123abc"',
-    "-0x123"     => '--- "-0x123"',
-    "+0x123"     => '--- "+0x123"',
-    "0x123.456"  => '--- "0x123.456"',
-    'test'       => "--- test",
-    []           => "--- []",
-    :symbol      => "--- !ruby/sym symbol",
-    {:a => "A"}  => "--- \n  !ruby/sym a: A",
-    {:a => "x\ny"} => "--- \n  !ruby/sym a: |-\n    x\n    y",
-  }.each do |data, serialized|
-    it "should convert the #{data.class} #{data.inspect} to yaml" do
-      data.should be_equivalent_to serialized
-    end
-  end
-
-  context Time do
-    def the_time_in(timezone)
-      Puppet::Util.withenv("TZ" => timezone) do
-        Time.local(2012, "dec", 11, 15, 59, 2)
-      end
-    end
-
-    def the_time_in_yaml_offset_by(offset)
-      "--- 2012-12-11 15:59:02.000000 #{offset}"
-    end
-
-    it "serializes a time in UTC" do
-      bad_rubies =
-        RUBY_VERSION[0,3] == '1.8' ||
-        RUBY_VERSION[0,3] == '2.0' && RUBY_PLATFORM == 'i386-mingw32'
-
-      pending("not supported on Windows", :if => Puppet.features.microsoft_windows? && bad_rubies) do
-        the_time_in("Europe/London").should be_equivalent_to(the_time_in_yaml_offset_by("+00:00"))
-      end
-    end
-
-    it "serializes a time behind UTC" do
-      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
-        the_time_in("America/Chicago").should be_equivalent_to(the_time_in_yaml_offset_by("-06:00"))
-      end
-    end
-
-    it "serializes a time behind UTC that is not a complete hour (Bug #15496)" do
-      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
-        the_time_in("America/Caracas").should be_equivalent_to(the_time_in_yaml_offset_by("-04:30"))
-      end
-    end
-
-    it "serializes a time ahead of UTC" do
-      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
-        the_time_in("Europe/Berlin").should be_equivalent_to(the_time_in_yaml_offset_by("+01:00"))
-      end
-    end
-
-    it "serializes a time ahead of UTC that is not a complete hour" do
-      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
-        the_time_in("Asia/Kathmandu").should be_equivalent_to(the_time_in_yaml_offset_by("+05:45"))
-      end
-    end
-
-    it "serializes a time more than 12 hours ahead of UTC" do
-      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
-        the_time_in("Pacific/Kiritimati").should be_equivalent_to(the_time_in_yaml_offset_by("+14:00"))
-      end
-    end
-
-    it "should roundtrip Time.now" do
-      tm = Time.now
-      # yaml only emits 6 digits of precision, but on some systems with ruby 1.9
-      # the original time object may contain nanoseconds, which will cause
-      # the equality check to fail. So truncate the time object to only microsecs
-      tm = Time.at(tm.to_i, tm.usec)
-      tm.should round_trip_through_yaml
-    end
-  end
-
-  [
-    { :a => "a:" },
-    { :a => "a:", :b => "b:" },
-    ["a:", "b:"],
-    { :a => "/:", :b => "/:" },
-    { :a => "a/:", :b => "a/:" },
-    { :a => "\"" },
-    { :a => {}.to_yaml },
-    { :a => [].to_yaml },
-    { :a => "".to_yaml },
-    { :a => :a.to_yaml },
-
-    { "a:" => "b" },
-    { :a.to_yaml => "b" },
-    { [1, 2, 3] => "b" },
-    { "b:" => { "a" => [] } }
-  ].each do |value|
-    it "properly escapes #{value.inspect}, which contains YAML characters" do
-      value.should round_trip_through_yaml
-    end
-  end
-
-  #
-  # Can't test for equality on raw objects
-  {
-    Object.new                   => "--- !ruby/object {}",
-    [Object.new]                 => "--- \n  - !ruby/object {}",
-    {Object.new => Object.new}   => "--- \n  ? !ruby/object {}\n  : !ruby/object {}"
-  }.each do |o,y|
-    it "should convert the #{o.class} #{o.inspect} to yaml" do
-      o.to_yaml.should == y
-    end
-    it "should produce yaml for the #{o.class} #{o.inspect} that can be reconstituted" do
-      lambda { YAML.load(o.to_yaml) }.should_not raise_error
-    end
-  end
-
-  it "should emit proper labels and backreferences for common objects" do
-    # Note: this test makes assumptions about the names ZAML chooses
-    # for labels.
-    x = [1, 2]
-    y = [3, 4]
-    z = [x, y, x, y]
-    z.should be_equivalent_to("--- \n  - &id001\n    - 1\n    - 2\n  - &id002\n    - 3\n    - 4\n  - *id001\n  - *id002")
-  end
-
-  it "should emit proper labels and backreferences for recursive objects" do
-    x = [1, 2]
-    x << x
-    x.to_yaml.should == "--- &id001\n  \n  - 1\n  - 2\n  - *id001"
-    x2 = YAML.load(x.to_yaml)
-    x2.should be_a(Array)
-    x2.length.should == 3
-    x2[0].should == 1
-    x2[1].should == 2
-    x2[2].should equal(x2)
-  end
-
-  # Note, many of these tests will pass on Ruby 1.8 but fail on 1.9 if the patch
-  # fix is not applied to Puppet or there's a regression.  These version
-  # dependant failures are intentional since the string encoding behavior changed
-  # significantly in 1.9.
-  context "UTF-8 encoded String#to_yaml (Bug #11246)" do
-    # JJM All of these snowmen are different representations of the same
-    # UTF-8 encoded string.
-    let(:snowman)         { 'Snowman: [☃]' }
-    let(:snowman_escaped) { "Snowman: [\xE2\x98\x83]" }
-
-    it "should serialize and deserialize to the same thing" do
-      snowman.should round_trip_through_yaml
-    end
-
-    it "should serialize and deserialize to a String compatible with a UTF-8 encoded Regexp" do
-      YAML.load(snowman.to_yaml).should =~ /☃/u
-    end
-  end
-
-  context "binary data" do
-    subject { "M\xC0\xDF\xE5tt\xF6" }
-
-    if String.method_defined?(:encoding)
-      def binary(str)
-        str.force_encoding('binary')
-      end
-    else
-      def binary(str)
-        str
-      end
-    end
-
-    it "should not explode encoding binary data" do
-      expect { subject.to_yaml }.not_to raise_error
-    end
-
-    it "should mark the binary data as binary" do
-      subject.to_yaml.should =~ /!binary/
-    end
-
-    it "should round-trip the data" do
-      yaml = subject.to_yaml
-      read = YAML.load(yaml)
-      binary(read).should == binary(subject)
-    end
-
-    [
-      "\xC0\xAE",                 # over-long UTF-8 '.' character
-      "\xC0\x80",                 # over-long NULL byte
-      "\xC0\xFF",
-      "\xC1\xAE",
-      "\xC1\x80",
-      "\xC1\xFF",
-      "\x80",                     # first continuation byte
-      "\xbf",                     # last continuation byte
-      # all possible continuation bytes in one shot
-      "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F" +
-      "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F" +
-      "\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF" +
-      "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
-      # lonely start characters - first, all possible two byte sequences
-      "\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 \xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF " +
-      "\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 \xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",
-      # and so for three byte sequences, four, five, and six, as follow.
-      "\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 \xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
-      "\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",
-      "\xF8 \xF9 \xFA \xFB ",
-      "\xFC \xFD ",
-      # sequences with the last byte missing
-      "\xC0", "\xE0", "\xF0\x80\x80", "\xF8\x80\x80\x80", "\xFC\x80\x80\x80\x80",
-      "\xDF", "\xEF\xBF", "\xF7\xBF\xBF", "\xFB\xBF\xBF\xBF", "\xFD\xBF\xBF\xBF\xBF",
-      # impossible bytes
-      "\xFE", "\xFF", "\xFE\xFE\xFF\xFF",
-      # over-long '/' character
-      "\xC0\xAF",
-      "\xE0\x80\xAF",
-      "\xF0\x80\x80\xAF",
-      "\xF8\x80\x80\x80\xAF",
-      "\xFC\x80\x80\x80\x80\xAF",
-      # maximum overlong sequences
-      "\xc1\xbf",
-      "\xe0\x9f\xbf",
-      "\xf0\x8f\xbf\xbf",
-      "\xf8\x87\xbf\xbf\xbf",
-      "\xfc\x83\xbf\xbf\xbf\xbf",
-      # overlong NUL
-      "\xc0\x80",
-      "\xe0\x80\x80",
-      "\xf0\x80\x80\x80",
-      "\xf8\x80\x80\x80\x80",
-      "\xfc\x80\x80\x80\x80\x80",
-    ].each do |input|
-      # It might seem like we should more correctly reject these sequences in
-      # the encoder, and I would personally agree, but the sad reality is that
-      # we do not distinguish binary and textual data in our language, and so we
-      # wind up with the same thing - a string - containing both.
-      #
-      # That leads to the position where we must treat these invalid sequences,
-      # which are both legitimate binary content, and illegitimate potential
-      # attacks on the system, as something that passes through correctly in
-      # a string. --daniel 2012-07-14
-      it "binary encode highly dubious non-compliant UTF-8 input #{input.inspect}" do
-        encoded = ZAML.dump(binary(input))
-        encoded.should =~ /!binary/
-        YAML.load(encoded).should == input
-      end
-    end
-  end
-
-  context "multi-line values" do
-    [
-      "none",
-      "one\n",
-      "two\n\n",
-      ["one\n", "two"],
-      ["two\n\n", "three"],
-      { "\nkey"        => "value" },
-      { "key\n"        => "value" },
-      { "\nkey\n"      => "value" },
-      { "key\nkey"     => "value" },
-      { "\nkey\nkey"   => "value" },
-      { "key\nkey\n"   => "value" },
-      { "\nkey\nkey\n" => "value" },
-    ].each do |input|
-      it "handles #{input.inspect} without corruption" do
-        input.should round_trip_through_yaml
-      end
-    end
-  end
-end