diff --git a/lib/puppet/application/resource.rb b/lib/puppet/application/resource.rb
index 76d0fada8..31e5524b6 100644
--- a/lib/puppet/application/resource.rb
+++ b/lib/puppet/application/resource.rb
@@ -1,223 +1,222 @@
 require 'puppet/application'
 
 class Puppet::Application::Resource < Puppet::Application
 
   should_not_parse_config
 
   attr_accessor :host, :extra_params
 
   def preinit
     @extra_params = []
-    @host = nil
     Facter.loadfacts
   end
 
   option("--debug","-d")
   option("--verbose","-v")
   option("--edit","-e")
 
   option("--host HOST","-H") do |arg|
     @host = arg
   end
 
   option("--types", "-t") do |arg|
     types = []
     Puppet::Type.loadall
     Puppet::Type.eachtype do |t|
       next if t.name == :component
       types << t.name.to_s
     end
     puts types.sort
     exit
   end
 
   option("--param PARAM", "-p") do |arg|
     @extra_params << arg.to_sym
   end
 
   def help
     <<-HELP
 
 puppet-resource(8) -- The resource abstraction layer shell
 ========
 
 SYNOPSIS
 --------
 Uses the Puppet RAL to directly interact with the system.
 
 
 USAGE
 -----
 puppet resource [-h|--help] [-d|--debug] [-v|--verbose] [-e|--edit]
   [-H|--host <host>] [-p|--param <parameter>] [-t|--types] <type>
   [<name>] [<attribute>=<value> ...]
 
 
 DESCRIPTION
 -----------
 This command provides simple facilities for converting current system
 state into Puppet code, along with some ability to modify the current
 state using Puppet's RAL.
 
 By default, you must at least provide a type to list, in which case
 puppet resource will tell you everything it knows about all resources of
 that type. You can optionally specify an instance name, and puppet
 resource will only describe that single instance.
 
 If given a type, a name, and a series of <attribute>=<value> pairs,
 puppet resource will modify the state of the specified resource.
 Alternately, if given a type, a name, and the '--edit' flag, puppet
 resource will write its output to a file, open that file in an editor,
 and then apply the saved file as a Puppet transaction.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' as an
 argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet with
 '--genconfig'.
 
 * --debug:
   Enable full debugging.
 
 * --edit:
   Write the results of the query to a file, open the file in an editor,
   and read the file back in as an executable Puppet manifest.
 
 * --host:
   When specified, connect to the resource server on the named host
   and retrieve the list of resouces of the type specified.
 
 * --help:
   Print this help message.
 
 * --param:
   Add more parameters to be outputted from queries.
 
 * --types:
   List all available types.
 
 * --verbose:
   Print extra information.
 
 
 EXAMPLE
 -------
 This example uses `puppet resource` to return a Puppet configuration for
 the user `luke`:
 
     $ puppet resource user luke
     user { 'luke':
      home => '/home/luke',
      uid => '100',
      ensure => 'present',
      comment => 'Luke Kanies,,,',
      gid => '1000',
      shell => '/bin/bash',
      groups => ['sysadmin','audio','video','puppet']
     }
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def main
     args = command_line.args
     type = args.shift or raise "You must specify the type to display"
     typeobj = Puppet::Type.type(type) or raise "Could not find type #{type}"
     name = args.shift
     params = {}
     args.each do |setting|
       if setting =~ /^(\w+)=(.+)$/
         params[$1] = $2
       else
         raise "Invalid parameter setting #{setting}"
       end
     end
 
     raise "You cannot edit a remote host" if options[:edit] and @host
 
     properties = typeobj.properties.collect { |s| s.name }
 
     format = proc {|trans|
-      trans.dup.collect do |param, value|
+      trans.dup.collect do |attribute, value|
         if value.nil? or value.to_s.empty?
-          trans.delete(param)
-        elsif value.to_s == "absent" and param.to_s != "ensure"
-          trans.delete(param)
+          trans.delete(attribute)
+        elsif value.to_s == "absent" and attribute.to_s != "ensure"
+          trans.delete(attribute)
         end
 
-        trans.delete(param) unless properties.include?(param) or @extra_params.include?(param)
+        trans.delete(attribute) unless properties.include?(attribute) or @extra_params.include?(attribute)
       end
       trans.to_manifest
     }
 
     if @host
       Puppet::Resource.indirection.terminus_class = :rest
       port = Puppet[:puppetport]
       key = ["https://#{host}:#{port}", "production", "resources", type, name].join('/')
     else
       key = [type, name].join('/')
     end
 
     text = if name
       if params.empty?
         [ Puppet::Resource.indirection.find( key ) ]
       else
         [ Puppet::Resource.indirection.save(Puppet::Resource.new( type, name, :parameters => params ), key) ]
       end
     else
       if type == "file"
         raise "Listing all file instances is not supported.  Please specify a file or directory, e.g. puppet resource file /etc"
       end
       Puppet::Resource.indirection.search( key, {} )
     end.map(&format).join("\n")
 
     if options[:edit]
       file = "/tmp/x2puppet-#{Process.pid}.pp"
       begin
         File.open(file, "w") do |f|
           f.puts text
         end
         ENV["EDITOR"] ||= "vi"
         system(ENV["EDITOR"], file)
         system("puppet -v #{file}")
       ensure
         #if FileTest.exists? file
         #    File.unlink(file)
         #end
       end
     else
       puts text
     end
   end
 
   def setup
     Puppet::Util::Log.newdestination(:console)
 
     # Now parse the config
     Puppet.parse_config
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
   end
 end
diff --git a/spec/unit/application/resource_spec.rb b/spec/unit/application/resource_spec.rb
index b6ed8598d..826b68d9a 100755
--- a/spec/unit/application/resource_spec.rb
+++ b/spec/unit/application/resource_spec.rb
@@ -1,250 +1,220 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/resource'
 
 describe Puppet::Application::Resource do
   before :each do
     @resource = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
     @resource.should_parse_config?.should be_false
   end
 
-  it "should declare a main command" do
-    @resource.should respond_to(:main)
-  end
-
-  it "should declare a host option" do
-    @resource.should respond_to(:handle_host)
-  end
-
-  it "should declare a types option" do
-    @resource.should respond_to(:handle_types)
-  end
-
-  it "should declare a param option" do
-    @resource.should respond_to(:handle_param)
-  end
-
-  it "should declare a preinit block" do
-    @resource.should respond_to(:preinit)
-  end
-
   describe "in preinit" do
-    it "should set hosts to nil", :'fails_on_ruby_1.9.2' => true do
-      @resource.preinit
-
-      @resource.host.should be_nil
-    end
-
     it "should init extra_params to empty array", :'fails_on_ruby_1.9.2' => true do
       @resource.preinit
 
       @resource.extra_params.should == []
     end
 
     it "should load Facter facts" do
       Facter.expects(:loadfacts).once
       @resource.preinit
     end
   end
 
   describe "when handling options" do
 
     [:debug, :verbose, :edit].each do |option|
-      it "should declare handle_#{option} method" do
-        @resource.should respond_to("handle_#{option}".to_sym)
-      end
-
       it "should store argument value when calling handle_#{option}" do
         @resource.options.expects(:[]=).with(option, 'arg')
         @resource.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set options[:host] to given host" do
       @resource.handle_host(:whatever)
 
       @resource.host.should == :whatever
     end
 
     it "should load an display all types with types option" do
       type1 = stub_everything 'type1', :name => :type1
       type2 = stub_everything 'type2', :name => :type2
       Puppet::Type.stubs(:loadall)
       Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
       @resource.expects(:puts).with(['type1','type2'])
       expect { @resource.handle_types(nil) }.to exit_with 0
     end
 
     it "should add param to extra_params list" do
       @resource.extra_params = [ :param1 ]
       @resource.handle_param("whatever")
 
       @resource.extra_params.should == [ :param1, :whatever ]
     end
   end
 
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:parse_config)
     end
 
 
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @resource.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @resource.options.stubs(:[]).with(:debug).returns(true)
       @resource.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @resource.options.stubs(:[]).with(:debug).returns(false)
       @resource.options.stubs(:[]).with(:verbose).returns(true)
       @resource.setup
       Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
       @resource.setup
     end
   end
 
   describe "when running" do
 
     before :each do
       @type = stub_everything 'type', :properties => []
-      @resource.command_line.stubs(:args).returns(['type'])
+      @resource.command_line.stubs(:args).returns(['mytype'])
       Puppet::Type.stubs(:type).returns(@type)
     end
 
     it "should raise an error if no type is given" do
       @resource.command_line.stubs(:args).returns([])
-      lambda { @resource.main }.should raise_error
+      lambda { @resource.main }.should raise_error(RuntimeError, "You must specify the type to display")
     end
 
     it "should raise an error when editing a remote host" do
       @resource.options.stubs(:[]).with(:edit).returns(true)
       @resource.host = 'host'
 
-      lambda { @resource.main }.should raise_error
+      lambda { @resource.main }.should raise_error(RuntimeError, "You cannot edit a remote host")
     end
 
     it "should raise an error if the type is not found" do
       Puppet::Type.stubs(:type).returns(nil)
 
-      lambda { @resource.main }.should raise_error
+      lambda { @resource.main }.should raise_error(RuntimeError, 'Could not find type mytype')
     end
 
     describe "with a host" do
       before :each do
         @resource.stubs(:puts)
         @resource.host = 'host'
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
         @resource.command_line.stubs(:args).returns(['type'])
         Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
         @resource.main
       end
 
       it "should describe the given resource" do
         @resource.command_line.stubs(:args).returns(['type', 'name'])
         x = stub_everything 'resource'
         Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(x)
         @resource.main
       end
 
       it "should add given parameters to the object" do
         @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
 
         res = stub "resource"
         Puppet::Resource.indirection.expects(:save).with(res, 'https://host:8139/production/resources/type/name').returns(res)
         res.expects(:collect)
         res.expects(:to_manifest)
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
 
         @resource.main
       end
 
     end
 
     describe "without a host" do
       before :each do
         @resource.stubs(:puts)
         @resource.host = nil
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
-        Puppet::Resource.indirection.expects(:search).with('type/', {}).returns([])
+        Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
         @resource.main
       end
 
       it "should describe the given resource" do
         @resource.command_line.stubs(:args).returns(['type','name'])
         x = stub_everything 'resource'
         Puppet::Resource.indirection.expects(:find).with('type/name').returns(x)
         @resource.main
       end
 
       it "should add given parameters to the object" do
         @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
 
         res = stub "resource"
         Puppet::Resource.indirection.expects(:save).with(res, 'type/name').returns(res)
         res.expects(:collect)
         res.expects(:to_manifest)
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
 
         @resource.main
       end
 
     end
   end
 
   describe "when handling file type" do
     before :each do
       Facter.stubs(:loadfacts)
       @resource.preinit
     end
 
     it "should raise an exception if no file specified" do
       @resource.command_line.stubs(:args).returns(['file'])
 
       lambda { @resource.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
     end
 
     it "should output a file resource when given a file path" do
       path = File.expand_path('/etc')
       res = Puppet::Type.type(:file).new(:path => path).to_resource
       Puppet::Resource.indirection.expects(:find).returns(res)
 
       @resource.command_line.stubs(:args).returns(['file', path])
       @resource.expects(:puts).with do |args|
         args.should =~ /file \{ '#{Regexp.escape(path)}'/m
       end
 
       @resource.main
     end
   end
 end