diff --git a/spec/unit/application/resource.rb b/spec/unit/application/resource.rb
index ebb8c4f3e..6224ee083 100755
--- a/spec/unit/application/resource.rb
+++ b/spec/unit/application/resource.rb
@@ -1,254 +1,255 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/resource'
 
 describe "resource" do
     before :each do
         @resource = Puppet::Application[:resource]
         Puppet::Util::Log.stubs(:newdestination)
         Puppet::Util::Log.stubs(:level=)
+        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(:run_preinit)
     end
 
     describe "in preinit" do
         it "should set hosts to nil" do
             @resource.run_preinit
 
             @resource.host.should be_nil
         end
 
         it "should init extra_params to empty array" do
             @resource.run_preinit
 
             @resource.extra_params.should == []
         end
 
         it "should load Facter facts" do
           Facter.expects(:loadfacts).once
           @resource.run_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.stubs(:exit)
 
             @resource.expects(:puts).with(['type1','type2'])
             @resource.handle_types(nil)
         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::Log.stubs(:level=)
             Puppet.stubs(:parse_config)
         end
 
 
         it "should set console as the log destination" do
             Puppet::Log.expects(:newdestination).with(:console)
 
             @resource.run_setup
         end
 
         it "should set log level to debug if --debug was passed" do
             @resource.options.stubs(:[]).with(:debug).returns(true)
 
             Puppet::Log.expects(:level=).with(:debug)
 
             @resource.run_setup
         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)
 
             Puppet::Log.expects(:level=).with(:info)
 
             @resource.run_setup
         end
 
         it "should Parse puppet config" do
             Puppet.expects(:parse_config)
 
             @resource.run_setup
         end
     end
 
     describe "when running" do
 
         def set_args(args)
             (ARGV.clear << args).flatten!
         end
 
         def push_args(*args)
             @args_stack ||= []
             @args_stack << ARGV.dup
             set_args(args)
         end
 
         def pop_args
             set_args(@args_stack.pop)
         end
 
         before :each do
             @type = stub_everything 'type', :properties => []
             push_args('type')
             Puppet::Type.stubs(:type).returns(@type)
         end
 
         after :each do
             pop_args
         end
 
         it "should raise an error if no type is given" do
             push_args
             lambda { @resource.main }.should raise_error
             pop_args
         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
         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
         end
 
         describe "with a host" do
             before :each do
                 @resource.stubs(:puts)
                 @resource.host = 'host'
 
                 Puppet::Resource.stubs(:find  ).never
                 Puppet::Resource.stubs(:search).never
                 Puppet::Resource.stubs(:save  ).never
             end
 
             it "should search for resources" do
                 Puppet::Resource.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
                 @resource.main
             end
 
             it "should describe the given resource" do
                 push_args('type','name')
                 x = stub_everything 'resource'
                 Puppet::Resource.expects(:find).with('https://host:8139/production/resources/type/name').returns(x)
                 @resource.main
                 pop_args
             end
 
             it "should add given parameters to the object" do
                 push_args('type','name','param=temp')
 
                 res = stub "resource"
                 res.expects(:save).with('https://host:8139/production/resources/type/name').returns(res)
                 res.expects(:collect)
                 res.expects(:to_manifest)
                 Puppet::Resource.expects(:new).with('type', 'name', {'param' => 'temp'}).returns(res)
 
                 @resource.main
                 pop_args
             end
 
         end
 
         describe "without a host" do
             before :each do
                 @resource.stubs(:puts)
                 @resource.host = nil
 
                 Puppet::Resource.stubs(:find  ).never
                 Puppet::Resource.stubs(:search).never
                 Puppet::Resource.stubs(:save  ).never
             end
 
             it "should search for resources" do
                 Puppet::Resource.expects(:search).with('type/', {}).returns([])
                 @resource.main
             end
 
             it "should describe the given resource" do
                 push_args('type','name')
                 x = stub_everything 'resource'
                 Puppet::Resource.expects(:find).with('type/name').returns(x)
                 @resource.main
                 pop_args
             end
 
             it "should add given parameters to the object" do
                 push_args('type','name','param=temp')
 
                 res = stub "resource"
                 res.expects(:save).with('type/name').returns(res)
                 res.expects(:collect)
                 res.expects(:to_manifest)
                 Puppet::Resource.expects(:new).with('type', 'name', {'param' => 'temp'}).returns(res)
 
                 @resource.main
                 pop_args
             end
 
         end
     end
 end