diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 9894f2f9e..31237e3b1 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -1,479 +1,486 @@
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/util/pson'
 
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
 class Puppet::Resource
   include Puppet::Util::Tagging
 
   require 'puppet/resource/type_collection_helper'
   include Puppet::Resource::TypeCollectionHelper
 
   extend Puppet::Util::Pson
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict
   attr_reader :namespaces
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
   ATTRIBUTES = [:file, :line, :exported]
 
   def self.from_pson(pson)
     raise ArgumentError, "No resource type provided in pson data" unless type = pson['type']
     raise ArgumentError, "No resource title provided in pson data" unless title = pson['title']
 
     resource = new(type, title)
 
     if params = pson['parameters']
       params.each { |param, value| resource[param] = value }
     end
 
     if tags = pson['tags']
       tags.each { |tag| resource.tag(tag) }
     end
 
     ATTRIBUTES.each do |a|
       if value = pson[a.to_s]
         resource.send(a.to_s + "=", value)
       end
     end
 
     resource.exported ||= false
 
     resource
   end
 
   def to_pson_data_hash
     data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
       next hash unless value = self.send(param)
       hash[param.to_s] = value
       hash
     end
 
     data["exported"] ||= false
 
     params = self.to_hash.inject({}) do |hash, ary|
       param, value = ary
 
       # Don't duplicate the title as the namevar
       next hash if param == namevar and value == title
-      if value.is_a? Puppet::Resource
-        hash[param] = value.to_s
-      else
-        hash[param] = value
-      end
+
+      hash[param] = Puppet::Resource.value_to_pson_data(value)
       hash
     end
 
     data["parameters"] = params unless params.empty?
 
     data
   end
 
+  def self.value_to_pson_data(value)
+    if value.is_a? Array
+      value.map{|v| value_to_pson_data(v) }
+    elsif value.is_a? Puppet::Resource
+      value.to_s
+    else
+      value
+    end
+  end
+
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Proxy these methods to the parameters hash.  It's likely they'll
   # be overridden at some point, but this works for now.
   %w{has_key? keys length delete empty? <<}.each do |method|
     define_method(method) do |*args|
       @parameters.send(method, *args)
     end
   end
 
   # Set a given parameter.  Converts all passed names
   # to lower-case symbols.
   def []=(param, value)
     validate_parameter(param) if validate_parameters
     @parameters[parameter_name(param)] = value
   end
 
   # Return a given parameter's value.  Converts all passed names
   # to lower-case symbols.
   def [](param)
     @parameters[parameter_name(param)]
   end
 
   def ==(other)
     return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
 
     return false unless to_hash == other.to_hash
     true
   end
 
   # Compatibility method.
   def builtin?
     builtin_type?
   end
 
   # Is this a builtin resource type?
   def builtin_type?
     resource_type.is_a?(Class)
   end
 
   # Iterate over each param/value pair, as required for Enumerable.
   def each
     @parameters.each { |p,v| yield p, v }
   end
 
   def include?(parameter)
     super || @parameters.keys.include?( parameter_name(parameter) )
   end
 
   # These two methods are extracted into a Helper
   # module, but file load order prevents me
   # from including them in the class, and I had weird
   # behaviour (i.e., sometimes it didn't work) when
   # I directly extended each resource with the helper.
   def environment
     Puppet::Node::Environment.new(@environment)
   end
 
   def environment=(env)
     if env.is_a?(String) or env.is_a?(Symbol)
       @environment = env
     else
       @environment = env.name
     end
   end
 
   %w{exported virtual strict}.each do |m|
     define_method(m+"?") do
       self.send(m)
     end
   end
 
   # Create our resource.
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
     @namespaces = [""]
 
     # Set things like namespaces and strictness first.
     attributes.each do |attr, value|
       next if attr == :parameters
       send(attr.to_s + "=", value)
     end
 
     # We do namespaces first, and use tmp variables, so our title
     # canonicalization works (i.e., namespaces are set and resource
     # types can be looked up)
     tmp_type, tmp_title = extract_type_and_title(type, title)
     self.type = tmp_type
     self.title = tmp_title
 
     if params = attributes[:parameters]
       extract_parameters(params)
     end
 
     resolve_type_and_title
 
     tag(self.type)
     tag(self.title) if valid_tag?(self.title)
 
     raise ArgumentError, "Invalid resource type #{type}" if strict? and ! resource_type
   end
 
   def ref
     to_s
   end
 
   # Find our resource.
   def resolve
     return(catalog ? catalog.resource(to_s) : nil)
   end
 
   def title=(value)
     @unresolved_title = value
     @title = nil
   end
 
   def resource_type
     case type
     when "Class"; find_hostclass(title)
     when "Node"; find_node(title)
     else
       find_resource_type(type)
     end
   end
 
   # Produce a simple hash of our parameters.
   def to_hash
     parse_title.merge @parameters
   end
 
   def to_s
     "#{type}[#{title}]"
   end
 
   def uniqueness_key
     self.to_hash.values_at(*key_attributes.sort_by { |k| k.to_s })
   end
 
   def key_attributes
     return(resource_type.respond_to? :key_attributes) ? resource_type.key_attributes : [:name]
   end
 
   # Convert our resource to Puppet code.
   def to_manifest
     "%s { '%s':\n%s\n}" % [self.type.to_s.downcase, self.title,
       @parameters.collect { |p, v|
         if v.is_a? Array
           "    #{p} => [\'#{v.join("','")}\']"
         else
           "    #{p} => \'#{v}\'"
         end
       }.join(",\n")
       ]
   end
 
   def to_ref
     ref
   end
 
   # Convert our resource to a RAL resource instance.  Creates component
   # instances for resource types that don't exist.
   def to_ral
     if typeklass = Puppet::Type.type(self.type)
       return typeklass.new(self)
     else
       return Puppet::Type::Component.new(self)
     end
   end
 
   # Translate our object to a backward-compatible transportable object.
   def to_trans
     if builtin_type? and type.downcase.to_s != "stage"
       result = to_transobject
     else
       result = to_transbucket
     end
 
     result.file = self.file
     result.line = self.line
 
     result
   end
 
   def to_trans_ref
     [type.to_s, title.to_s]
   end
 
   # Create an old-style TransObject instance, for builtin resource types.
   def to_transobject
     # Now convert to a transobject
     result = Puppet::TransObject.new(title, type)
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = v.to_trans_ref
       elsif v.is_a?(Array)
         v = v.collect { |av|
           av = av.to_trans_ref if av.is_a?(Puppet::Resource)
           av
         }
       end
 
       # If the value is an array with only one value, then
       # convert it to a single value.  This is largely so that
       # the database interaction doesn't have to worry about
       # whether it returns an array or a string.
       result[p.to_s] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.tags = self.tags
 
     result
   end
 
   def name
     # this is potential namespace conflict
     # between the notion of an "indirector name"
     # and a "resource name"
     [ type, title ].join('/')
   end
 
   def to_resource
     self
   end
 
   # We have to lazy-evaluate this.
   def title=(value)
     @title = nil
     @unresolved_title = value
   end
 
   # We have to lazy-evaluate this.
   def type=(value)
     @type = nil
     @unresolved_type = value || "Class"
   end
 
   def title
     resolve_type_and_title unless @title
     @title
   end
 
   def type
     resolve_type_and_title unless @type
     @type
   end
 
   def valid_parameter?(name)
     resource_type.valid_parameter?(name)
   end
 
   def validate_parameter(name)
     raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
   end
 
   private
 
   def find_node(name)
     known_resource_types.node(name)
   end
 
   def find_hostclass(title)
     name = title == :main ? "" : title
     known_resource_types.find_hostclass(namespaces, name)
   end
 
   def find_resource_type(type)
     # It still works fine without the type == 'class' short-cut, but it is a lot slower.
     find_builtin_resource_type(type) || find_defined_resource_type(type) unless type.to_s.downcase == 'class'
   end
 
   def find_builtin_resource_type(type)
     Puppet::Type.type(type.to_s.downcase.to_sym)
   end
 
   def find_defined_resource_type(type)
     known_resource_types.find_definition(namespaces, type.to_s.downcase)
   end
 
   # Produce a canonical method name.
   def parameter_name(param)
     param = param.to_s.downcase.to_sym
     if param == :name and n = namevar
       param = namevar
     end
     param
   end
 
   def namespaces=(ns)
     @namespaces = Array(ns)
   end
 
   # The namevar for our resource type. If the type doesn't exist,
   # always use :name.
   def namevar
     if builtin_type? and t = resource_type and t.key_attributes.length == 1
       t.key_attributes.first
     else
       :name
     end
   end
 
   # Create an old-style TransBucket instance, for non-builtin resource types.
   def to_transbucket
     bucket = Puppet::TransBucket.new([])
 
     bucket.type = self.type
     bucket.name = self.title
 
     # TransBuckets don't support parameters, which is why they're being deprecated.
     bucket
   end
 
   def extract_parameters(params)
     params.each do |param, value|
       validate_parameter(param) if strict?
       self[param] = value
     end
   end
 
   def extract_type_and_title(argtype, argtitle)
     if    (argtitle || argtype) =~ /^([^\[\]]+)\[(.+)\]$/m then [ $1,                 $2            ]
     elsif argtitle                                         then [ argtype,            argtitle      ]
     elsif argtype.is_a?(Puppet::Type)                      then [ argtype.class.name, argtype.title ]
     else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
     end
   end
 
   def munge_type_name(value)
     return :main if value == :main
     return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
 
     value.to_s.split("::").collect { |s| s.capitalize }.join("::")
   end
 
   # This is an annoyingly complicated method for resolving qualified
   # types as necessary, and putting them in type or title attributes.
   def resolve_type_and_title
     if @unresolved_type
       @type = resolve_type
       @unresolved_type = nil
     end
     if @unresolved_title
       @title = resolve_title
       @unresolved_title = nil
     end
   end
 
   def resolve_type
     case type = munge_type_name(@unresolved_type)
     when "Class", "Node";
       type
     else
       # Otherwise, some kind of builtin or defined resource type
       munge_type_name( (r = find_resource_type(type)) ? r.name : type)
     end
   end
 
   # This method only works if resolve_type was called first
   def resolve_title
     case @type
     when "Node"; return @unresolved_title
     when "Class";
       resolve_title_for_class(@unresolved_title)
     else
       @unresolved_title
     end
   end
 
   def resolve_title_for_class(title)
     if title == "" or title == :main
       return :main
     end
 
     if klass = find_hostclass(title)
       result = klass.name
     end
     munge_type_name(result || title)
   end
 
   def parse_title
     h = {}
     type = find_resource_type(@type)
     if type.respond_to? :title_patterns
       type.title_patterns.each { |regexp, symbols_and_lambdas|
         if captures = regexp.match(title.to_s)
           symbols_and_lambdas.zip(captures[1..-1]).each { |symbol_and_lambda,capture|
             sym, lam = symbol_and_lambda
             #self[sym] = lam.call(capture)
             h[sym] = lam.call(capture)
           }
           return h
         end
       }
     else
       return { :name => title.to_s }
     end
   end
 end
diff --git a/spec/unit/resource_spec.rb b/spec/unit/resource_spec.rb
index aff3816c2..95f0dd04b 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -1,805 +1,812 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/resource'
 
 describe Puppet::Resource do
 
   before do
     @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
   end
 
   [:catalog, :file, :line].each do |attr|
     it "should have an #{attr} attribute" do
       resource = Puppet::Resource.new("file", "/my/file")
       resource.should respond_to(attr)
       resource.should respond_to(attr.to_s + "=")
     end
   end
 
   it "should have a :title attribute" do
     Puppet::Resource.new(:user, "foo").title.should == "foo"
   end
 
   it "should require the type and title" do
     lambda { Puppet::Resource.new }.should raise_error(ArgumentError)
   end
 
   it "should canonize types to capitalized strings" do
     Puppet::Resource.new(:user, "foo").type.should == "User"
   end
 
   it "should canonize qualified types so all strings are capitalized" do
     Puppet::Resource.new("foo::bar", "foo").type.should == "Foo::Bar"
   end
 
   it "should tag itself with its type" do
     Puppet::Resource.new("file", "/f").should be_tagged("file")
   end
 
   it "should tag itself with its title if the title is a valid tag" do
     Puppet::Resource.new("user", "bar").should be_tagged("bar")
   end
 
   it "should not tag itself with its title if the title is a not valid tag" do
     Puppet::Resource.new("file", "/bar").should_not be_tagged("/bar")
   end
 
   it "should allow setting of attributes" do
     Puppet::Resource.new("file", "/bar", :file => "/foo").file.should == "/foo"
     Puppet::Resource.new("file", "/bar", :exported => true).should be_exported
   end
 
   it "should set its type to 'Class' and its title to the passed title if the passed type is :component and the title has no square brackets in it" do
     ref = Puppet::Resource.new(:component, "foo")
     ref.type.should == "Class"
     ref.title.should == "Foo"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is :component and the title contains square brackets" do
     ref = Puppet::Resource.new(:component, "foo::bar[yay]")
     ref.type.should == "Foo::Bar"
     ref.title.should == "yay"
   end
 
   it "should set the type to 'Class' if it is nil and the title contains no square brackets" do
     ref = Puppet::Resource.new(nil, "yay")
     ref.type.should == "Class"
     ref.title.should == "Yay"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains square brackets" do
     ref = Puppet::Resource.new(nil, "foo::bar[yay]")
     ref.type.should == "Foo::Bar"
     ref.title.should == "yay"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains nested square brackets" do
     ref = Puppet::Resource.new(nil, "foo::bar[baz[yay]]")
     ref.type.should == "Foo::Bar"
     ref.title.should =="baz[yay]"
   end
 
   it "should interpret the type as a reference and assign appropriately if the title is nil and the type contains square brackets" do
     ref = Puppet::Resource.new("foo::bar[baz]")
     ref.type.should == "Foo::Bar"
     ref.title.should =="baz"
   end
 
   it "should be able to extract its information from a Puppet::Type instance" do
     ral = Puppet::Type.type(:file).new :path => @basepath+"/foo"
     ref = Puppet::Resource.new(ral)
     ref.type.should == "File"
     ref.title.should == @basepath+"/foo"
   end
 
 
   it "should fail if the title is nil and the type is not a valid resource reference string" do
     lambda { Puppet::Resource.new("foo") }.should raise_error(ArgumentError)
   end
 
   it "should be able to produce a backward-compatible reference array" do
     Puppet::Resource.new("foobar", "/f").to_trans_ref.should == %w{Foobar /f}
   end
 
   it "should be taggable" do
     Puppet::Resource.ancestors.should be_include(Puppet::Util::Tagging)
   end
 
   it "should have an 'exported' attribute" do
     resource = Puppet::Resource.new("file", "/f")
     resource.exported = true
     resource.exported.should == true
     resource.should be_exported
   end
 
   it "should support an environment attribute" do
     Puppet::Resource.new("file", "/my/file", :environment => :foo).environment.name.should == :foo
   end
 
   it "should support specifying namespaces" do
     Puppet::Resource.new("file", "/my/file", :namespaces => ["foo"]).namespaces.should == ["foo"]
   end
 
   it "should convert namespaces to an array if not specified as one" do
     Puppet::Resource.new("file", "/my/file", :namespaces => "foo").namespaces.should == ["foo"]
   end
 
   it "should default to a single amespace of an empty string" do
     Puppet::Resource.new("file", "/my/file").namespaces.should == [""]
   end
 
   describe "and munging its type and title" do
     describe "when modeling a builtin resource" do
       it "should be able to find the resource type" do
         Puppet::Resource.new("file", "/my/file").resource_type.should equal(Puppet::Type.type(:file))
       end
 
       it "should set its type to the capitalized type name" do
         Puppet::Resource.new("file", "/my/file").type.should == "File"
       end
     end
 
     describe "when modeling a defined resource" do
       describe "that exists" do
         before do
           @type = Puppet::Resource::Type.new(:definition, "foo::bar")
           Puppet::Node::Environment.new.known_resource_types.add @type
         end
 
         it "should set its type to the capitalized type name" do
           Puppet::Resource.new("foo::bar", "/my/file").type.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
           Puppet::Resource.new("foo::bar", "/my/file").resource_type.should equal(@type)
         end
 
         it "should set its title to the provided title" do
           Puppet::Resource.new("foo::bar", "/my/file").title.should == "/my/file"
         end
 
         describe "and the resource is unqualified and models a qualified resource type" do
           it "should set its type to the fully qualified resource type" do
             Puppet::Resource.new("bar", "/my/file", :namespaces => %w{foo}).type.should == "Foo::Bar"
           end
 
           it "should be able to find the resource type" do
             Puppet::Resource.new("bar", "/my/file", :namespaces => %w{foo}).resource_type.should equal(@type)
           end
         end
       end
 
       describe "that does not exist" do
         it "should set its resource type to the capitalized resource type name" do
           Puppet::Resource.new("foo::bar", "/my/file").type.should == "Foo::Bar"
         end
       end
     end
 
     describe "when modeling a node" do
       # Life's easier with nodes, because they can't be qualified.
       it "should set its type to 'Node' and its title to the provided title" do
         node = Puppet::Resource.new("node", "foo")
         node.type.should == "Node"
         node.title.should == "foo"
       end
     end
 
     describe "when modeling a class" do
       it "should set its type to 'Class'" do
         Puppet::Resource.new("class", "foo").type.should == "Class"
       end
 
       describe "that exists" do
         before do
           @type = Puppet::Resource::Type.new(:hostclass, "foo::bar")
           Puppet::Node::Environment.new.known_resource_types.add @type
         end
 
         it "should set its title to the capitalized, fully qualified resource type" do
           Puppet::Resource.new("class", "foo::bar").title.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
           Puppet::Resource.new("class", "foo::bar").resource_type.should equal(@type)
         end
 
         describe "and the resource is unqualified and models a qualified class" do
           it "should set its title to the fully qualified resource type" do
             Puppet::Resource.new("class", "bar", :namespaces => %w{foo}).title.should == "Foo::Bar"
           end
 
           it "should be able to find the resource type" do
             Puppet::Resource.new("class", "bar", :namespaces => %w{foo}).resource_type.should equal(@type)
           end
 
           it "should set its type to 'Class'" do
             Puppet::Resource.new("class", "bar", :namespaces => %w{foo}).type.should == "Class"
           end
         end
       end
 
       describe "that does not exist" do
         it "should set its type to 'Class' and its title to the capitalized provided name" do
           klass = Puppet::Resource.new("class", "foo::bar")
           klass.type.should == "Class"
           klass.title.should == "Foo::Bar"
         end
       end
 
       describe "and its name is set to the empty string" do
         it "should set its title to :main" do
           Puppet::Resource.new("class", "").title.should == :main
         end
 
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
           it "should set its title to :main" do
             @type = Puppet::Resource::Type.new(:hostclass, "")
             Puppet::Node::Environment.new.known_resource_types.add @type
 
             Puppet::Resource.new("class", "").title.should == :main
           end
         end
       end
 
       describe "and its name is set to :main" do
         it "should set its title to :main" do
           Puppet::Resource.new("class", :main).title.should == :main
         end
 
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
           it "should set its title to :main" do
             @type = Puppet::Resource::Type.new(:hostclass, "")
             Puppet::Node::Environment.new.known_resource_types.add @type
 
             Puppet::Resource.new("class", :main).title.should == :main
           end
         end
       end
     end
   end
 
   it "should return nil when looking up resource types that don't exist" do
     Puppet::Resource.new("foobar", "bar").resource_type.should be_nil
   end
 
   it "should not fail when an invalid parameter is used and strict mode is disabled" do
     type = Puppet::Resource::Type.new(:definition, "foobar")
     Puppet::Node::Environment.new.known_resource_types.add type
     resource = Puppet::Resource.new("foobar", "/my/file")
     resource[:yay] = true
   end
 
   it "should be considered equivalent to another resource if their type and title match and no parameters are set" do
     Puppet::Resource.new("file", "/f").should == Puppet::Resource.new("file", "/f")
   end
 
   it "should be considered equivalent to another resource if their type, title, and parameters are equal" do
     Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"}).should == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
   end
 
   it "should not be considered equivalent to another resource if their type and title match but parameters are different" do
     Puppet::Resource.new("file", "/f", :parameters => {:fee => "baz"}).should_not == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
   end
 
   it "should not be considered equivalent to a non-resource" do
     Puppet::Resource.new("file", "/f").should_not == "foo"
   end
 
   it "should not be considered equivalent to another resource if their types do not match" do
     Puppet::Resource.new("file", "/f").should_not == Puppet::Resource.new("exec", "/f")
   end
 
   it "should not be considered equivalent to another resource if their titles do not match" do
     Puppet::Resource.new("file", "/foo").should_not == Puppet::Resource.new("file", "/f")
   end
 
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")
       res.uniqueness_key.should == ["/path"]
       res.ref.should == "File[/path/]"
     end
   end
 
   describe "when running in strict mode" do
     it "should be strict" do
       Puppet::Resource.new("file", "/path", :strict => true).should be_strict
     end
 
     it "should fail if invalid parameters are used" do
       lambda { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.should raise_error
     end
 
     it "should fail if the resource type cannot be resolved" do
       lambda { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.should raise_error
     end
   end
 
   describe "when managing parameters" do
     before do
       @resource = Puppet::Resource.new("file", "/my/file")
     end
 
     it "should correctly detect when provided parameters are not valid for builtin types" do
       Puppet::Resource.new("file", "/my/file").should_not be_valid_parameter("foobar")
     end
 
     it "should correctly detect when provided parameters are valid for builtin types" do
       Puppet::Resource.new("file", "/my/file").should be_valid_parameter("mode")
     end
 
     it "should correctly detect when provided parameters are not valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar")
       Puppet::Node::Environment.new.known_resource_types.add type
       Puppet::Resource.new("foobar", "/my/file").should_not be_valid_parameter("myparam")
     end
 
     it "should correctly detect when provided parameters are valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar", :arguments => {"myparam" => nil})
       Puppet::Node::Environment.new.known_resource_types.add type
       Puppet::Resource.new("foobar", "/my/file").should be_valid_parameter("myparam")
     end
 
     it "should allow setting and retrieving of parameters" do
       @resource[:foo] = "bar"
       @resource[:foo].should == "bar"
     end
 
     it "should allow setting of parameters at initialization" do
       Puppet::Resource.new("file", "/my/file", :parameters => {:foo => "bar"})[:foo].should == "bar"
     end
 
     it "should canonicalize retrieved parameter names to treat symbols and strings equivalently" do
       @resource[:foo] = "bar"
       @resource["foo"].should == "bar"
     end
 
     it "should canonicalize set parameter names to treat symbols and strings equivalently" do
       @resource["foo"] = "bar"
       @resource[:foo].should == "bar"
     end
 
     it "should set the namevar when asked to set the name" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:name] = "bob"
       resource[:myvar].should == "bob"
     end
 
     it "should return the namevar when asked to return the name" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:myvar] = "test"
       resource[:name].should == "test"
     end
 
     it "should be able to set the name for non-builtin types" do
       resource = Puppet::Resource.new(:foo, "bar")
       resource[:name] = "eh"
       lambda { resource[:name] = "eh" }.should_not raise_error
     end
 
     it "should be able to return the name for non-builtin types" do
       resource = Puppet::Resource.new(:foo, "bar")
       resource[:name] = "eh"
       resource[:name].should == "eh"
     end
 
     it "should be able to iterate over parameters" do
       @resource[:foo] = "bar"
       @resource[:fee] = "bare"
       params = {}
       @resource.each do |key, value|
         params[key] = value
       end
       params.should == {:foo => "bar", :fee => "bare"}
     end
 
     it "should include Enumerable" do
       @resource.class.ancestors.should be_include(Enumerable)
     end
 
     it "should have a method for testing whether a parameter is included" do
       @resource[:foo] = "bar"
       @resource.should be_has_key(:foo)
       @resource.should_not be_has_key(:eh)
     end
 
     it "should have a method for providing the list of parameters" do
       @resource[:foo] = "bar"
       @resource[:bar] = "foo"
       keys = @resource.keys
       keys.should be_include(:foo)
       keys.should be_include(:bar)
     end
 
     it "should have a method for providing the number of parameters" do
       @resource[:foo] = "bar"
       @resource.length.should == 1
     end
 
     it "should have a method for deleting parameters" do
       @resource[:foo] = "bar"
       @resource.delete(:foo)
       @resource[:foo].should be_nil
     end
 
     it "should have a method for testing whether the parameter list is empty" do
       @resource.should be_empty
       @resource[:foo] = "bar"
       @resource.should_not be_empty
     end
 
     it "should be able to produce a hash of all existing parameters" do
       @resource[:foo] = "bar"
       @resource[:fee] = "yay"
 
       hash = @resource.to_hash
       hash[:foo].should == "bar"
       hash[:fee].should == "yay"
     end
 
     it "should not provide direct access to the internal parameters hash when producing a hash" do
       hash = @resource.to_hash
       hash[:foo] = "bar"
       @resource[:foo].should be_nil
     end
 
     it "should use the title as the namevar to the hash if no namevar is present" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource.to_hash[:myvar].should == "bob"
     end
 
     it "should set :name to the title if :name is not present for non-builtin types" do
       krt = Puppet::Resource::TypeCollection.new("myenv")
       krt.add Puppet::Resource::Type.new(:definition, :foo)
       resource = Puppet::Resource.new :foo, "bar"
       resource.stubs(:known_resource_types).returns krt
       resource.to_hash[:name].should == "bar"
     end
   end
 
   describe "when serializing" do
     before do
       @resource = Puppet::Resource.new("file", "/my/file")
       @resource["one"] = "test"
       @resource["two"] = "other"
     end
 
     it "should be able to be dumped to yaml" do
       proc { YAML.dump(@resource) }.should_not raise_error
     end
 
     it "should produce an equivalent yaml object" do
       text = YAML.dump(@resource)
 
       newresource = YAML.load(text)
       newresource.title.should == @resource.title
       newresource.type.should == @resource.type
       %w{one two}.each do |param|
         newresource[param].should == @resource[param]
       end
     end
   end
 
   describe "when converting to a RAL resource" do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", @basepath+"/my/file")
       result = resource.to_ral
       result.should be_instance_of(Puppet::Type.type(:file))
       result[:path].should == @basepath+"/my/file"
     end
 
     it "should convert to a component instance if the resource type is not of a builtin type" do
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
       result.should be_instance_of(Puppet::Type.type(:component))
       result.title.should == "Foobar[somename]"
     end
   end
 
   it "should be able to convert itself to Puppet code" do
     Puppet::Resource.new("one::two", "/my/file").should respond_to(:to_manifest)
   end
 
   describe "when converting to puppet code" do
     before do
       @resource = Puppet::Resource.new("one::two", "/my/file", :parameters => {:noop => true, :foo => %w{one two}})
     end
 
     it "should print the type and title" do
       @resource.to_manifest.should be_include("one::two { '/my/file':\n")
     end
 
     it "should print each parameter, with the value single-quoted" do
       @resource.to_manifest.should be_include("    noop => 'true'")
     end
 
     it "should print array values appropriately" do
       @resource.to_manifest.should be_include("    foo => ['one','two']")
     end
   end
 
   it "should be able to convert itself to a TransObject instance" do
     Puppet::Resource.new("one::two", "/my/file").should respond_to(:to_trans)
   end
 
   describe "when converting to a TransObject" do
     describe "and the resource is not an instance of a builtin type" do
       before do
         @resource = Puppet::Resource.new("foo", "bar")
       end
 
       it "should return a simple TransBucket if it is not an instance of a builtin type" do
         bucket = @resource.to_trans
         bucket.should be_instance_of(Puppet::TransBucket)
         bucket.type.should == @resource.type
         bucket.name.should == @resource.title
       end
 
       it "should return a simple TransBucket if it is a stage" do
         @resource = Puppet::Resource.new("stage", "bar")
         bucket = @resource.to_trans
         bucket.should be_instance_of(Puppet::TransBucket)
         bucket.type.should == @resource.type
         bucket.name.should == @resource.title
       end
 
       it "should copy over the resource's file" do
         @resource.file = "/foo/bar"
         @resource.to_trans.file.should == "/foo/bar"
       end
 
       it "should copy over the resource's line" do
         @resource.line = 50
         @resource.to_trans.line.should == 50
       end
     end
 
     describe "and the resource is an instance of a builtin type" do
       before do
         @resource = Puppet::Resource.new("file", "bar")
       end
 
       it "should return a TransObject if it is an instance of a builtin resource type" do
         trans = @resource.to_trans
         trans.should be_instance_of(Puppet::TransObject)
         trans.type.should == "file"
         trans.name.should == @resource.title
       end
 
       it "should copy over the resource's file" do
         @resource.file = "/foo/bar"
         @resource.to_trans.file.should == "/foo/bar"
       end
 
       it "should copy over the resource's line" do
         @resource.line = 50
         @resource.to_trans.line.should == 50
       end
 
       # Only TransObjects support tags, annoyingly
       it "should copy over the resource's tags" do
         @resource.tag "foo"
         @resource.to_trans.tags.should == @resource.tags
       end
 
       it "should copy the resource's parameters into the transobject and convert the parameter name to a string" do
         @resource[:foo] = "bar"
         @resource.to_trans["foo"].should == "bar"
       end
 
       it "should be able to copy arrays of values" do
         @resource[:foo] = %w{yay fee}
         @resource.to_trans["foo"].should == %w{yay fee}
       end
 
       it "should reduce single-value arrays to just a value" do
         @resource[:foo] = %w{yay}
         @resource.to_trans["foo"].should == "yay"
       end
 
       it "should convert resource references into the backward-compatible form" do
         @resource[:foo] = Puppet::Resource.new(:file, "/f")
         @resource.to_trans["foo"].should == %w{File /f}
       end
 
       it "should convert resource references into the backward-compatible form even when within arrays" do
         @resource[:foo] = ["a", Puppet::Resource.new(:file, "/f")]
         @resource.to_trans["foo"].should == ["a", %w{File /f}]
       end
     end
   end
 
   describe "when converting to pson" do
     confine "Missing 'pson' library" => Puppet.features.pson?
 
     def pson_output_should
       @resource.class.expects(:pson_create).with { |hash| yield hash }
     end
 
     it "should include the pson util module" do
       Puppet::Resource.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
     end
 
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
 
     it "should set its type to the provided type" do
       Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type.should == "File"
     end
 
     it "should set its title to the provided title" do
       Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title.should == "/foo"
     end
 
     it "should include all tags from the resource" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.tag("yay")
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).tags.should == resource.tags
     end
 
     it "should include the file if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.file = "/my/file"
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).file.should == "/my/file"
     end
 
     it "should include the line if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.line = 50
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).line.should == 50
     end
 
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_true
     end
 
     it "should set 'exported' to false if no value is set" do
       resource = Puppet::Resource.new("File", "/foo")
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_false
     end
 
     it "should set all of its parameters as the 'parameters' entry" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:foo] = %w{bar eh}
       resource[:fee] = %w{baz}
 
       result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
       result["foo"].should == %w{bar eh}
       result["fee"].should == %w{baz}
     end
 
     it "should serialize relationships as reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = Puppet::Resource.new("File", "/bar")
       result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
       result[:requires].should == "File[/bar]"
     end
+
+    it "should serialize multiple relationships as arrays of reference strings" do
+      resource = Puppet::Resource.new("File", "/foo")
+      resource[:requires] = [Puppet::Resource.new("File", "/bar"), Puppet::Resource.new("File", "/baz")]
+      result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
+      result[:requires].should == [ "File[/bar]",  "File[/baz]" ]
+    end
   end
 
   describe "when converting from pson" do
     confine "Missing 'pson' library" => Puppet.features.pson?
 
     def pson_result_should
       Puppet::Resource.expects(:new).with { |hash| yield hash }
     end
 
     before do
       @data = {
         'type' => "file",
         'title' => @basepath+"/yay",
       }
     end
 
     it "should set its type to the provided type" do
       Puppet::Resource.from_pson(@data).type.should == "File"
     end
 
     it "should set its title to the provided title" do
       Puppet::Resource.from_pson(@data).title.should == @basepath+"/yay"
     end
 
     it "should tag the resource with any provided tags" do
       @data['tags'] = %w{foo bar}
       resource = Puppet::Resource.from_pson(@data)
       resource.tags.should be_include("foo")
       resource.tags.should be_include("bar")
     end
 
     it "should set its file to the provided file" do
       @data['file'] = "/foo/bar"
       Puppet::Resource.from_pson(@data).file.should == "/foo/bar"
     end
 
     it "should set its line to the provided line" do
       @data['line'] = 50
       Puppet::Resource.from_pson(@data).line.should == 50
     end
 
     it "should 'exported' to true if set in the pson data" do
       @data['exported'] = true
       Puppet::Resource.from_pson(@data).exported.should be_true
     end
 
     it "should 'exported' to false if not set in the pson data" do
       Puppet::Resource.from_pson(@data).exported.should be_false
     end
 
     it "should fail if no title is provided" do
       @data.delete('title')
       lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
     end
 
     it "should fail if no type is provided" do
       @data.delete('type')
       lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
     end
 
     it "should set each of the provided parameters" do
       @data['parameters'] = {'foo' => %w{one two}, 'fee' => %w{three four}}
       resource = Puppet::Resource.from_pson(@data)
       resource['foo'].should == %w{one two}
       resource['fee'].should == %w{three four}
     end
 
     it "should convert single-value array parameters to normal values" do
       @data['parameters'] = {'foo' => %w{one}}
       resource = Puppet::Resource.from_pson(@data)
       resource['foo'].should == %w{one}
     end
   end
 
   describe "it should implement to_resource" do
     resource = Puppet::Resource.new("file", "/my/file")
     resource.to_resource.should == resource
   end
 
   describe "because it is an indirector model" do
     it "should include Puppet::Indirector" do
       Puppet::Resource.should be_is_a(Puppet::Indirector)
     end
 
     it "should have a default terminus" do
       Puppet::Resource.indirection.terminus_class.should == :ral
     end
 
     it "should have a name" do
       Puppet::Resource.new("file", "/my/file").name.should == "File//my/file"
     end
   end
 
   describe "when resolving resources with a catalog" do
     it "should resolve all resources using the catalog" do
       catalog = mock 'catalog'
       resource = Puppet::Resource.new("foo::bar", "yay")
       resource.catalog = catalog
 
       catalog.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
 
       resource.resolve.should == :myresource
     end
   end
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
       Puppet::Type.type(:file).stubs(:key_attributes).returns [:myvar, :owner, :path]
       Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})
       res.uniqueness_key.should == [ nil, 'root', '/my/file']
     end
   end
 end