diff --git a/lib/puppet/parser/functions/create_resources.rb b/lib/puppet/parser/functions/create_resources.rb
index 3c91b4111..9a5304dec 100644
--- a/lib/puppet/parser/functions/create_resources.rb
+++ b/lib/puppet/parser/functions/create_resources.rb
@@ -1,75 +1,76 @@
 Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC') do |args|
     Converts a hash into a set of resources and adds them to the catalog.
 
     This function takes two mandatory arguments: a resource type, and a hash describing
     a set of resources. The hash should be in the form `{title => {parameters} }`:
 
         # A hash of user resources:
         $myusers = {
           'nick' => { uid    => '1330',
                       group  => allstaff,
                       groups => ['developers', 'operations', 'release'], }
           'dan'  => { uid    => '1308',
                       group  => allstaff,
                       groups => ['developers', 'prosvc', 'release'], }
         }
 
         create_resources(user, $myusers)
 
     A third, optional parameter may be given, also as a hash:
 
         $defaults => {
           'ensure'   => present,
           'provider' => 'ldap',
         }
 
         create_resources(user, $myusers, $defaults)
 
     The values given on the third argument are added to the parameters of each resource
     present in the set given on the second argument. If a parameter is present on both
     the second and third arguments, the one on the second argument takes precedence.
 
     This function can be used to create defined resources and classes, as well
     as native resources.
   ENDHEREDOC
   raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2 or 3)") if args.length < 2 || args.length > 3
 
   # figure out what kind of resource we are
   type_of_resource = nil
   type_name = args[0].downcase
   if type_name == 'class'
     type_of_resource = :class
   else
     if resource = Puppet::Type.type(type_name.to_sym)
       type_of_resource = :type
     elsif resource = find_definition(type_name.downcase)
       type_of_resource = :define
     else
       raise ArgumentError, "could not create resource of unknown type #{type_name}"
     end
   end
   # iterate through the resources to create
   defaults = args[2] || {}
   args[1].each do |title, params|
-    raise ArgumentError, 'params should not contain title' if(params['title'])
     params = defaults.merge(params)
+    Puppet::Util.symbolizehash!(params)
+    raise ArgumentError, 'params should not contain title' if(params[:title])
     case type_of_resource
     # JJM The only difference between a type and a define is the call to instantiate_resource
     # for a defined type.
     when :type, :define
       p_resource = Puppet::Parser::Resource.new(type_name, title, :scope => self, :source => resource)
-      params.merge(:name => title).each do |k,v|
+      {:name => title}.merge(params).each do |k,v|
         p_resource.set_parameter(k,v)
       end
       if type_of_resource == :define then
         resource.instantiate_resource(self, p_resource)
       end
       compiler.add_resource(self, p_resource)
     when :class
       klass = find_hostclass(title)
       raise ArgumentError, "could not find hostclass #{title}" unless klass
       klass.ensure_in_catalog(self, params)
       compiler.catalog.add_class(title)
     end
   end
 end
diff --git a/spec/unit/parser/functions/create_resources_spec.rb b/spec/unit/parser/functions/create_resources_spec.rb
index 0eca7182f..8d4d5d855 100755
--- a/spec/unit/parser/functions/create_resources_spec.rb
+++ b/spec/unit/parser/functions/create_resources_spec.rb
@@ -1,157 +1,171 @@
 require 'puppet'
 require 'spec_helper'
 
 describe 'function for dynamically creating resources' do
 
   def get_scope
     @topscope = Puppet::Parser::Scope.new
     # This is necessary so we don't try to use the compiler to discover our parent.
     @topscope.parent = nil
     @scope = Puppet::Parser::Scope.new
     @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
     @scope.parent = @topscope
     @compiler = @scope.compiler
   end
   before :each do
     get_scope
     Puppet::Parser::Functions.function(:create_resources)
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function(:create_resources).should == "function_create_resources"
   end
 
   it 'should require two or three arguments' do
     expect { @scope.function_create_resources(['foo']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (1; must be 2 or 3)')
     expect { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
   end
 
+  describe 'when the caller does not supply a name parameter' do
+    it 'should set a default resource name equal to the resource title' do
+      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'test').once
+      @scope.function_create_resources(['notify', {'test'=>{}}])
+    end
+  end
+  describe 'when the caller supplies a name parameter' do
+    it 'should set the resource name to the value provided' do
+      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'user_supplied').once
+      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'test').never
+      @scope.function_create_resources(['notify', {'test'=>{'name' => 'user_supplied'}}])
+    end
+  end
+
   describe 'when creating native types' do
     before :each do
       Puppet[:code]='notify{test:}'
       get_scope
       @scope.resource=Puppet::Parser::Resource.new('class', 't', :scope => @scope)
     end
 
     it 'empty hash should not cause resources to be added' do
       @scope.function_create_resources(['file', {}])
       @compiler.catalog.resources.size == 1
     end
     it 'should be able to add' do
       @scope.function_create_resources(['file', {'/etc/foo'=>{'ensure'=>'present'}}])
       @compiler.catalog.resource(:file, "/etc/foo")['ensure'].should == 'present'
     end
     it 'should accept multiple types' do
       type_hash = {}
       type_hash['foo'] = {'message' => 'one'}
       type_hash['bar'] = {'message' => 'two'}
       @scope.function_create_resources(['notify', type_hash])
       @compiler.catalog.resource(:notify, "foo")['message'].should == 'one'
       @compiler.catalog.resource(:notify, "bar")['message'].should == 'two'
     end
     it 'should fail to add non-existing type' do
       expect { @scope.function_create_resources(['create-resource-foo', {}]) }.should raise_error(ArgumentError, 'could not create resource of unknown type create-resource-foo')
     end
     it 'should be able to add edges' do
       @scope.function_create_resources(['notify', {'foo'=>{'require' => 'Notify[test]'}}])
       @scope.compiler.compile
       rg = @scope.compiler.catalog.to_ral.relationship_graph
       test  = rg.vertices.find { |v| v.title == 'test' }
       foo   = rg.vertices.find { |v| v.title == 'foo' }
       test.should be
       foo.should be
       rg.path_between(test,foo).should be
     end
     it 'should account for default values' do
       @scope.function_create_resources(['file', {'/etc/foo'=>{'ensure'=>'present'}, '/etc/baz'=>{'group'=>'food'}}, {'group' => 'bar'}])
       @compiler.catalog.resource(:file, "/etc/foo")['group'].should == 'bar'
       @compiler.catalog.resource(:file, "/etc/baz")['group'].should == 'food'
     end
   end
   describe 'when dynamically creating resource types' do
     before :each do 
       Puppet[:code]=
 'define foocreateresource($one){notify{$name: message => $one}}
 notify{test:}
 '
       get_scope
       @scope.resource=Puppet::Parser::Resource.new('class', 't', :scope => @scope)
       Puppet::Parser::Functions.function(:create_resources)
     end
     it 'should be able to create defined resoure types' do
       @scope.function_create_resources(['foocreateresource', {'blah'=>{'one'=>'two'}}])
       # still have to compile for this to work...
       # I am not sure if this constraint ruins the tests
       @scope.compiler.compile
       @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
     end
     it 'should fail if defines are missing params' do
       @scope.function_create_resources(['foocreateresource', {'blah'=>{}}])
       expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, 'Must pass one to Foocreateresource[blah] at line 1')
     end
     it 'should be able to add multiple defines' do
       hash = {}
       hash['blah'] = {'one' => 'two'}
       hash['blaz'] = {'one' => 'three'}
       @scope.function_create_resources(['foocreateresource', hash])
       # still have to compile for this to work...
       # I am not sure if this constraint ruins the tests
       @scope.compiler.compile
       @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
       @compiler.catalog.resource(:notify, "blaz")['message'].should == 'three'
     end
     it 'should be able to add edges' do
       @scope.function_create_resources(['foocreateresource', {'blah'=>{'one'=>'two', 'require' => 'Notify[test]'}}])
       @scope.compiler.compile
       rg = @scope.compiler.catalog.to_ral.relationship_graph
       test = rg.vertices.find { |v| v.title == 'test' }
       blah = rg.vertices.find { |v| v.title == 'blah' }
       test.should be
       blah.should be
       # (Yoda speak like we do)
       rg.path_between(test,blah).should be
       @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
     end
     it 'should account for default values' do
       @scope.function_create_resources(['foocreateresource', {'blah'=>{}}, {'one' => 'two'}])
       @scope.compiler.compile
       @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
     end
   end
   describe 'when creating classes' do
     before :each do
       Puppet[:code]=
 'class bar($one){notify{test: message => $one}}
 notify{tester:}
 '
       get_scope
       @scope.resource=Puppet::Parser::Resource.new('class', 't', :scope => @scope)
       Puppet::Parser::Functions.function(:create_resources)
     end
     it 'should be able to create classes' do
       @scope.function_create_resources(['class', {'bar'=>{'one'=>'two'}}])
       @scope.compiler.compile
       @compiler.catalog.resource(:notify, "test")['message'].should == 'two'
       @compiler.catalog.resource(:class, "bar").should_not be_nil
     end
     it 'should fail to create non-existing classes' do
       expect { @scope.function_create_resources(['class', {'blah'=>{'one'=>'two'}}]) }.should raise_error(ArgumentError ,'could not find hostclass blah')
     end
     it 'should be able to add edges' do
       @scope.function_create_resources(['class', {'bar'=>{'one'=>'two', 'require' => 'Notify[tester]'}}])
       @scope.compiler.compile
       rg = @scope.compiler.catalog.to_ral.relationship_graph
       test   = rg.vertices.find { |v| v.title == 'test' }
       tester = rg.vertices.find { |v| v.title == 'tester' }
       test.should be
       tester.should be
       rg.path_between(tester,test).should be
     end
     it 'should account for default values' do
       @scope.function_create_resources(['class', {'bar'=>{}}, {'one' => 'two'}])
       @scope.compiler.compile
       @compiler.catalog.resource(:notify, "test")['message'].should == 'two'
       @compiler.catalog.resource(:class, "bar").should_not be_nil
     end
   end
 end