diff --git a/lib/puppet/indirector/resource/ral.rb b/lib/puppet/indirector/resource/ral.rb
index 5a366a329..350d722db 100644
--- a/lib/puppet/indirector/resource/ral.rb
+++ b/lib/puppet/indirector/resource/ral.rb
@@ -1,64 +1,64 @@
 require 'puppet/indirector/resource/validator'
 
 class Puppet::Resource::Ral < Puppet::Indirector::Code
   include Puppet::Resource::Validator
 
   desc "Manipulate resources with the resource abstraction layer. Only used internally."
 
   def allow_remote_requests?
     Puppet.deprecation_warning("Accessing resources on the network is deprecated. See http://links.puppetlabs.com/deprecate-networked-resource")
     super
   end
 
   def find( request )
     # find by name
     res   = type(request).instances.find { |o| o.name == resource_name(request) }
     res ||= type(request).new(:name => resource_name(request), :audit => type(request).properties.collect { |s| s.name })
 
     res.to_resource
   end
 
   def search( request )
     conditions = request.options.dup
     conditions[:name] = resource_name(request) if resource_name(request)
 
     type(request).instances.map do |res|
       res.to_resource
     end.find_all do |res|
       conditions.all? {|property, value| res.to_resource[property].to_s == value.to_s}
     end.sort do |a,b|
       a.title <=> b.title
     end
   end
 
   def save( request )
     # In RAL-land, to "save" means to actually try to change machine state
     res = request.instance
     ral_res = res.to_ral
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource ral_res
     transaction = catalog.apply
 
     [ral_res.to_resource, transaction.report]
   end
 
   private
 
   # {type,resource}_name: the resource name may contain slashes:
   # File["/etc/hosts"]. To handle, assume the type name does
   # _not_ have any slashes in it, and split only on the first.
 
   def type_name( request )
     request.key.split('/', 2)[0]
   end
 
   def resource_name( request )
     name = request.key.split('/', 2)[1]
     name unless name == ""
   end
 
   def type( request )
-    Puppet::Type.type(type_name(request)) or raise Puppet::Error, "Could not find type #{type}"
+    Puppet::Type.type(type_name(request)) or raise Puppet::Error, "Could not find type #{type_name(request)}"
   end
 end
diff --git a/spec/unit/indirector/resource/ral_spec.rb b/spec/unit/indirector/resource/ral_spec.rb
index 8b42f6881..36ba5f1c2 100755
--- a/spec/unit/indirector/resource/ral_spec.rb
+++ b/spec/unit/indirector/resource/ral_spec.rb
@@ -1,142 +1,147 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "Puppet::Resource::Ral" do
 
   it "is deprecated on the network, but still allows requests" do
     Puppet.expects(:deprecation_warning)
 
     expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(true)
   end
 
   describe "find" do
     before do
       @request = stub 'request', :key => "user/root"
     end
 
     it "should find an existing instance" do
       my_resource    = stub "my user resource"
 
       wrong_instance = stub "wrong user", :name => "bob"
       my_instance    = stub "my user",    :name => "root", :to_resource => my_resource
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ wrong_instance, my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.find(@request).should == my_resource
     end
 
+    it "should produce Puppet::Error instead of ArgumentError" do
+      @bad_request = stub 'thiswillcauseanerror', :key => "thiswill/causeanerror"
+      expect{Puppet::Resource::Ral.new.find(@bad_request)}.to raise_error(Puppet::Error)
+    end
+
     it "if there is no instance, it should create one" do
       wrong_instance = stub "wrong user", :name => "bob"
       root = mock "Root User"
       root_resource = mock "Root Resource"
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ wrong_instance, wrong_instance ])
       Puppet::Type::User.expects(:new).with(has_entry(:name => "root")).returns(root)
       root.expects(:to_resource).returns(root_resource)
 
       result = Puppet::Resource::Ral.new.find(@request)
 
       result.should == root_resource
     end
   end
 
   describe "search" do
     before do
       @request = stub 'request', :key => "user/", :options => {}
     end
 
     it "should convert ral resources into regular resources" do
       my_resource = stub "my user resource"
       my_instance = stub "my user", :name => "root", :to_resource => my_resource
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should filter results by name if there's a name in the key" do
       my_resource    = stub "my user resource"
       my_resource.stubs(:to_resource).returns(my_resource)
       my_resource.stubs(:[]).with(:name).returns("root")
 
       wrong_resource = stub "wrong resource"
       wrong_resource.stubs(:to_resource).returns(wrong_resource)
       wrong_resource.stubs(:[]).with(:name).returns("bad")
 
       my_instance    = stub "my user",    :to_resource => my_resource
       wrong_instance = stub "wrong user", :to_resource => wrong_resource
 
       @request = stub 'request', :key => "user/root", :options => {}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should filter results by query parameters" do
       wrong_resource = stub "my user resource"
       wrong_resource.stubs(:to_resource).returns(wrong_resource)
       wrong_resource.stubs(:[]).with(:name).returns("root")
 
       my_resource = stub "wrong resource"
       my_resource.stubs(:to_resource).returns(my_resource)
       my_resource.stubs(:[]).with(:name).returns("bob")
 
       my_instance    = stub "my user",    :to_resource => my_resource
       wrong_instance = stub "wrong user", :to_resource => wrong_resource
 
       @request = stub 'request', :key => "user/", :options => {:name => "bob"}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should return sorted results" do
       a_resource = stub "alice resource"
       a_resource.stubs(:to_resource).returns(a_resource)
       a_resource.stubs(:title).returns("alice")
 
       b_resource = stub "bob resource"
       b_resource.stubs(:to_resource).returns(b_resource)
       b_resource.stubs(:title).returns("bob")
 
       a_instance = stub "alice user", :to_resource => a_resource
       b_instance = stub "bob user",   :to_resource => b_resource
 
       @request = stub 'request', :key => "user/", :options => {}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ b_instance, a_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [a_resource, b_resource]
     end
   end
 
   describe "save" do
     before do
       @rebuilt_res = stub 'rebuilt instance'
       @ral_res     = stub 'ral resource', :to_resource => @rebuilt_res
       @instance    = stub 'instance', :to_ral => @ral_res
       @request     = stub 'request',  :key => "user/", :instance => @instance
       @catalog     = stub 'catalog'
       @report      = stub 'report'
       @transaction = stub 'transaction', :report => @report
 
       Puppet::Resource::Catalog.stubs(:new).returns(@catalog)
       @catalog.stubs(:apply).returns(@transaction)
       @catalog.stubs(:add_resource)
     end
 
     it "should apply a new catalog with a ral object in it" do
       Puppet::Resource::Catalog.expects(:new).returns(@catalog)
       @catalog.expects(:add_resource).with(@ral_res)
       @catalog.expects(:apply).returns(@transaction)
       Puppet::Resource::Ral.new.save(@request).should
     end
 
     it "should return a regular resource that used to be the ral resource" do
       Puppet::Resource::Ral.new.save(@request).should == [@rebuilt_res, @report]
     end
   end
 end