diff --git a/lib/puppet/application/resource.rb b/lib/puppet/application/resource.rb
index 648340396..3a630d6c8 100644
--- a/lib/puppet/application/resource.rb
+++ b/lib/puppet/application/resource.rb
@@ -1,239 +1,226 @@
 require 'puppet/application'
 
 class Puppet::Application::Resource < Puppet::Application
 
   should_not_parse_config
 
   attr_accessor :host, :extra_params
 
   def preinit
     @extra_params = []
     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
     type, name, params = parse_args(command_line.args)
 
     raise "You cannot edit a remote host" if options[:edit] and @host
 
-    format = proc {|trans|
-      properties = trans.resource_type.properties.map(&:name)
-
-      trans.dup.collect do |attribute, value|
-        if value.nil? or value.to_s.empty?
-          trans.delete(attribute)
-        elsif value.to_s == "absent" and attribute.to_s != "ensure"
-          trans.delete(attribute)
-        end
-
-        trans.delete(attribute) unless properties.include?(attribute) or @extra_params.include?(attribute)
-      end
-      trans.to_manifest
-    }
-
     resources = find_or_save_resources(type, name, params)
-    text = resources.map(&format).join("\n")
+    text = resources.
+      map { |resource| resource.format_for_manifest(@extra_params) }.
+      join("\n")
 
     options[:edit] ?
       handle_editing(text) :
       (puts text)
   end
 
   def setup
     Puppet::Util::Log.newdestination(:console)
 
     Puppet.parse_config
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
   end
 
   private
 
   def remote_key(type, name)
     Puppet::Resource.indirection.terminus_class = :rest
     port = Puppet[:puppetport]
     ["https://#{@host}:#{port}", "production", "resources", type, name].join('/')
   end
 
   def local_key(type, name)
     [type, name].join('/')
   end
 
   def handle_editing(text)
     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 apply -v #{file}")
     ensure
       #if FileTest.exists? file
       #    File.unlink(file)
       #end
     end
   end
 
   def parse_args(args)
     type = args.shift or raise "You must specify the type to display"
     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
 
     [type, name, params]
   end
 
   def find_or_save_resources(type, name, params)
     key = @host ? remote_key(type, name) : local_key(type, name)
 
     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
   end
 end
diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 59e387d00..ee0dbacec 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -1,439 +1,454 @@
 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
   # This stub class is only needed for serialization compatibility with 0.25.x.
   # Specifically, it exists to provide a compatibility API when using YAML
   # serialized objects loaded from StoreConfigs.
   Reference = 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 :type, :title
 
   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 inspect
     "#{@type}[#{@title}]#{to_hash.inspect}"
   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
 
       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 yaml_property_munge(x)
     case x
     when Hash
       x.inject({}) { |h,kv|
         k,v = kv
         h[k] = self.class.value_to_pson_data(v)
         h
       }
     else self.class.value_to_pson_data(x)
     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 = {}
 
     # Set things like strictness first.
     attributes.each do |attr, value|
       next if attr == :parameters
       send(attr.to_s + "=", value)
     end
 
     @type, @title = extract_type_and_title(type, title)
 
     @type = munge_type_name(@type)
 
     if @type == "Class"
       @title = :main if @title == ""
       @title = munge_type_name(@title)
     end
 
     if params = attributes[:parameters]
       extract_parameters(params)
     end
 
     tag(self.type)
     tag(self.title) if valid_tag?(self.title)
 
     @reference = self # for serialization compatibility with 0.25.x
     if strict? and ! resource_type
       if @type == 'Class'
         raise ArgumentError, "Could not find declared class #{title}"
       else
         raise ArgumentError, "Invalid resource type #{type}"
       end
     end
   end
 
   def ref
     to_s
   end
 
   # Find our resource.
   def resolve
     return(catalog ? catalog.resource(to_s) : nil)
   end
 
   def resource_type
     case type
     when "Class"; known_resource_types.hostclass(title == :main ? "" : title)
     when "Node"; known_resource_types.node(title)
     else
       Puppet::Type.type(type.to_s.downcase.to_sym) || known_resource_types.definition(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
     # Temporary kludge to deal with inconsistant use patters
     h = self.to_hash
     h[namevar] ||= h[:name]
     h[:name]   ||= h[namevar]
     h.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
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
     attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
 
     attr.sort!
     if attr.first != :ensure  && attr.include?(:ensure)
       attr.delete(:ensure)
       attr.unshift(:ensure)
     end
 
     attributes = attr.collect { |k|
       v = parameters[k]
       if v.is_a? Array
         "  %-#{attr_max}s => %s,\n" % [ k, "[\'#{v.join("', '")}\']" ]
       else
         "  %-#{attr_max}s => %s,\n" % [ k, "\'#{v}\'" ]
       end
     }.join
 
     "%s { '%s':\n%s}" % [self.type.to_s.downcase, self.title, attributes]
   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
 
   def valid_parameter?(name)
     resource_type.valid_parameter?(name)
   end
 
   def validate_parameter(name)
     raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
   end
 
+  def format_for_manifest(parameters_to_include)
+    properties = resource_type.properties.map(&:name)
+
+    dup.collect do |attribute, value|
+      if value.nil? or value.to_s.empty?
+        delete(attribute)
+      elsif value.to_s == "absent" and attribute.to_s != "ensure"
+        delete(attribute)
+      end
+
+      delete(attribute) unless properties.include?(attribute) or parameters_to_include.include?(attribute)
+    end
+    to_manifest
+  end
+
   private
 
   # 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
 
   # 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 ]
     elsif argtype.is_a?(Hash)                              then
       raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
         "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
     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
 
   def parse_title
     h = {}
     type = resource_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
 
   def parameters
     # @parameters could have been loaded from YAML, causing it to be nil (by
     # bypassing initialize).
     @parameters ||= {}
   end
 end
diff --git a/spec/unit/application/resource_spec.rb b/spec/unit/application/resource_spec.rb
index e3e4c6738..1ac21a84a 100755
--- a/spec/unit/application/resource_spec.rb
+++ b/spec/unit/application/resource_spec.rb
@@ -1,213 +1,211 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/resource'
 
 describe Puppet::Application::Resource do
   before :each do
     @resource_app = 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_app.should_parse_config?.should be_false
   end
 
   describe "in preinit" do
     it "should init extra_params to empty array", :'fails_on_ruby_1.9.2' => true do
       @resource_app.preinit
       @resource_app.extra_params.should == []
     end
 
     it "should load Facter facts" do
       Facter.expects(:loadfacts).once
       @resource_app.preinit
     end
   end
 
   describe "when handling options" do
     [:debug, :verbose, :edit].each do |option|
       it "should store argument value when calling handle_#{option}" do
         @resource_app.options.expects(:[]=).with(option, 'arg')
         @resource_app.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set options[:host] to given host" do
       @resource_app.handle_host(:whatever)
       @resource_app.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_app.expects(:puts).with(['type1','type2'])
       expect { @resource_app.handle_types(nil) }.to exit_with 0
     end
 
     it "should add param to extra_params list" do
       @resource_app.extra_params = [ :param1 ]
       @resource_app.handle_param("whatever")
 
       @resource_app.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_app.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @resource_app.options.stubs(:[]).with(:debug).returns(true)
       @resource_app.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @resource_app.options.stubs(:[]).with(:debug).returns(false)
       @resource_app.options.stubs(:[]).with(:verbose).returns(true)
       @resource_app.setup
       Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
       @resource_app.setup
     end
   end
 
   describe "when running" do
     before :each do
       @type = stub_everything 'type', :properties => []
       @resource_app.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_app.command_line.stubs(:args).returns([])
       lambda { @resource_app.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_app.options.stubs(:[]).with(:edit).returns(true)
       @resource_app.host = 'host'
 
       lambda { @resource_app.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_app.main }.should raise_error(RuntimeError, 'Could not find type mytype')
     end
 
     describe "with a host" do
       before :each do
         @resource_app.stubs(:puts)
         @resource_app.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_app.command_line.stubs(:args).returns(['type'])
         Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
         @resource_app.main
       end
 
       it "should describe the given resource" do
         @resource_app.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_app.main
       end
 
       it "should add given parameters to the object" do
         @resource_app.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)
+        res.expects(:format_for_manifest)
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
 
         @resource_app.main
       end
     end
 
     describe "without a host" do
       before :each do
         @resource_app.stubs(:puts)
         @resource_app.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('mytype/', {}).returns([])
         @resource_app.main
       end
 
       it "should describe the given resource" do
         @resource_app.command_line.stubs(:args).returns(['type','name'])
         x = stub_everything 'resource'
         Puppet::Resource.indirection.expects(:find).with('type/name').returns(x)
         @resource_app.main
       end
 
       it "should add given parameters to the object" do
         @resource_app.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)
+        res.expects(:format_for_manifest)
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
 
         @resource_app.main
       end
     end
   end
 
   describe "when handling file type" do
     before :each do
       Facter.stubs(:loadfacts)
       @resource_app.preinit
     end
 
     it "should raise an exception if no file specified" do
       @resource_app.command_line.stubs(:args).returns(['file'])
 
       lambda { @resource_app.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_app.command_line.stubs(:args).returns(['file', path])
       @resource_app.expects(:puts).with do |args|
         args.should =~ /file \{ '#{Regexp.escape(path)}'/m
       end
 
       @resource_app.main
     end
   end
 end