ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/test/new_relic/control/logging_methods_test.rb

@@ -5,11 +5,15 @@ require 'fileutils'
 class BaseLoggingMethods
   # stub class to enable testing of the module
   include NewRelic::Control::LoggingMethods
+  include NewRelic::Control::Configuration
+  def root; "."; end
 end
 
 class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
   def setup
     @base = BaseLoggingMethods.new
+    @base.settings['log_file_path'] = 'log/'
+    @base.settings['log_file_name'] = 'newrelic_agent.log'
     super
   end
 
@@ -36,6 +40,7 @@ class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
 
   def test_logbang_should_not_log
     @base.expects(:should_log?).returns(false)
+    @base.stubs(:to_stdout)
     assert_equal nil, @base.log!('whee')
   end
 
@@ -89,20 +94,10 @@ class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
     assert fake_logger.respond_to?(:format_message)
   end
 
-  def test_setup_log_file_not_exist
-    @base.expects(:log_path).returns('logpath')
-    @base.expects(:log_file_name).returns('logfilename')
-    fake_logger = mock('logger')
-    @base.expects(:log).returns(fake_logger)
-    @base.setup_log
-    assert_equal nil, @base.instance_eval { @log }
-    assert_equal 'logpath/logfilename', @base.instance_eval { @log_file }
-  end
-
   def test_setup_log_existing_file
     fake_logger = mock('logger')
     Logger.expects(:new).with('logpath/logfilename').returns(fake_logger)
-    @base.expects(:log_path).returns('logpath')
+    @base.expects(:log_path).returns('logpath').at_least_once
     @base.expects(:log_file_name).returns('logfilename')
     @base.expects(:set_log_format!).with(fake_logger)
     @base.expects(:set_log_level!).with(fake_logger)
@@ -122,16 +117,15 @@ class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
   end
 
   def test_log_path_path_exists
-    @base.instance_eval { @log_path = nil }
-    @base.expects(:fetch).with('log_file_path', 'log/').returns('log/')
-    assert File.directory?('log/')
-    assert_equal File.expand_path('log/'), @base.log_path
+    @base.settings['log_file_path'] = 'log'
+    assert File.directory?('log')
+    assert_equal File.expand_path('log'), @base.log_path
   end
 
   def test_log_path_path_created
     path = File.expand_path('tmp/log_path_test')
     @base.instance_eval { @log_path = nil }
-    @base.expects(:fetch).with('log_file_path', 'log/').returns('tmp/log_path_test')
+    @base.settings['log_file_path'] = 'tmp/log_path_test'
     assert !File.directory?(path) || FileUtils.rmdir(path)
     @base.expects(:log!).never
     assert_equal path, @base.log_path
@@ -141,17 +135,51 @@ class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
   def test_log_path_path_unable_to_create
     path = File.expand_path('tmp/log_path_test')
     @base.instance_eval { @log_path = nil }
-    @base.expects(:fetch).with('log_file_path', 'log/').returns('tmp/log_path_test')
+    @base.settings['log_file_path'] = 'tmp/log_path_test'
     assert !File.directory?(path) || FileUtils.rmdir(path)
-    @base.expects(:log!).with("Error creating New Relic log directory '#{path}'", :error)
-    Dir.expects(:mkdir).with(path).raises('cannot make directory bro!')
-    assert_equal path, @base.log_path
+    @base.expects(:log!).with("Error creating log directory tmp/log_path_test, using standard out for logging.", :warn)
+    Dir.expects(:mkdir).with(path).raises('cannot make directory bro!').twice # once for the relative directory, once for the directory relative to Rails.root
+    assert_nil @base.log_path
     assert !File.directory?(path)
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev    
   end
 
   def test_log_file_name
     @base.expects(:fetch).with('log_file_name', 'newrelic_agent.log').returns('log_file_name')
     assert_equal 'log_file_name', @base.log_file_name
   end
-end
 
+  def test_log_to_stdout_when_log_file_path_set_to_STDOUT
+    @base.stubs(:fetch).returns('whatever')
+    @base.expects(:fetch).with('log_file_path', 'log').returns('STDOUT')
+    Dir.expects(:mkdir).never
+    @base.setup_log
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev    
+  end
+
+  def test_logs_to_stdout_include_newrelic_prefix
+    @base.stubs(:fetch).returns('whatever')
+    @base.expects(:fetch).with('log_file_path', 'log').returns('STDOUT')
+    STDOUT.expects(:write).with(regexp_matches(/\*\* \[NewRelic\].*whee/))
+    @base.setup_log
+    @base.log.info('whee')
+  end
+
+  def test_set_stdout_destination_from_NEW_RELIC_LOG_env_var
+    @base.stubs(:fetch).returns('whatever')
+    ENV['NEW_RELIC_LOG'] = 'stdout'
+    Dir.expects(:mkdir).never
+    @base.setup_log
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev
+    ENV['NEW_RELIC_LOG'] = nil
+  end
+
+  def test_set_file_destination_from_NEW_RELIC_LOG_env_var
+    @base.stubs(:fetch).returns('whatever')
+    ENV['NEW_RELIC_LOG'] = 'log/file.log'
+    @base.setup_log
+    assert_equal 'log', File.basename(@base.log_path)
+    assert_equal 'file.log', @base.log_file_name
+    ENV['NEW_RELIC_LOG'] = nil    
+  end
+end

data/test/new_relic/control_test.rb

@@ -1,33 +1,34 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
-class NewRelic::ControlTest < Test::Unit::TestCase
 
-  attr_reader :c
+class NewRelic::ControlTest < Test::Unit::TestCase
+  attr_reader :control
 
   def setup
-
     NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
-    @c =  NewRelic::Control.instance
+    @control =  NewRelic::Control.instance
     raise 'oh geez, wrong class' unless NewRelic::Control.instance.is_a?(::NewRelic::Control::Frameworks::Test)
   end
+
   def shutdown
     NewRelic::Agent.shutdown
   end
 
   def test_cert_file_path
-    assert @c.cert_file_path
-    assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @c.cert_file_path
+    assert @control.cert_file_path
+    assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @control.cert_file_path
   end
   
   # This test does not actually use the ruby agent in any way - it's
   # testing that the CA file we ship actually validates our server's
   # certificate. It's used for customers who enable verify_certificate
   def test_cert_file
+    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
     s   = TCPSocket.new 'collector.newrelic.com', 443
     ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = @c.cert_file_path
+    ctx.ca_file = @control.cert_file_path
     ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
     s   = OpenSSL::SSL::SSLSocket.new s, ctx
     s.connect
@@ -38,12 +39,13 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   # certificates in a non-customer-facing place before setting them
   # live.
   def test_staging_cert_file
+    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
     s   = TCPSocket.new 'staging-collector.newrelic.com', 443
     ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = @c.cert_file_path
+    ctx.ca_file = @control.cert_file_path
     ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
     s   = OpenSSL::SSL::SSLSocket.new s, ctx
     s.connect
@@ -51,39 +53,39 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_monitor_mode
-    assert ! @c.monitor_mode?
-    @c.settings.delete 'enabled'
-    @c.settings.delete 'monitor_mode'
-    assert !@c.monitor_mode?
-    @c['enabled'] = false
-    assert ! @c.monitor_mode?
-    @c['enabled'] = true
-    assert @c.monitor_mode?
-    @c['monitor_mode'] = nil
-    assert !@c.monitor_mode?
-    @c['monitor_mode'] = false
-    assert !@c.monitor_mode?
-    @c['monitor_mode'] = true
-    assert @c.monitor_mode?
+    assert ! @control.monitor_mode?
+    @control.settings.delete 'enabled'
+    @control.settings.delete 'monitor_mode'
+    assert !@control.monitor_mode?
+    @control['enabled'] = false
+    assert ! @control.monitor_mode?
+    @control['enabled'] = true
+    assert @control.monitor_mode?
+    @control['monitor_mode'] = nil
+    assert !@control.monitor_mode?
+    @control['monitor_mode'] = false
+    assert !@control.monitor_mode?
+    @control['monitor_mode'] = true
+    assert @control.monitor_mode?
   ensure
-    @c['enabled'] = false
-    @c['monitor_mode'] = false
+    @control['enabled'] = false
+    @control['monitor_mode'] = false
   end
 
   def test_test_config
     if defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
-      assert_equal :rails3, c.app
+      assert_equal :rails3, control.app
     elsif defined?(Rails)
-      assert_equal :rails, c.app
+      assert_equal :rails, control.app
     else
-      assert_equal :test, c.app
+      assert_equal :test, control.app
     end
-    assert_equal :test, c.framework
-    assert_match /test/i, c.dispatcher_instance_id
-    assert("" == c.dispatcher.to_s, "Expected dispatcher to be empty, but was #{c.dispatcher.to_s}")
-    assert !c['enabled']
-    assert_equal false, c['monitor_mode']
-    c.local_env
+    assert_equal :test, control.framework
+    assert_match /test/i, control.dispatcher_instance_id
+    assert("" == control.dispatcher.to_s, "Expected dispatcher to be empty, but was #{control.dispatcher.to_s}")
+    assert !control['enabled']
+    assert_equal false, control['monitor_mode']
+    control.local_env
   end
 
   def test_root
@@ -101,10 +103,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_resolve_ip
-    assert_equal nil, c.send(:convert_to_ip_address, 'localhost')
-    assert_equal nil, c.send(:convert_to_ip_address, 'q1239988737.us')
+    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
     # This will fail if you don't have a valid, accessible, DNS server
-    assert_equal '204.93.223.153', c.send(:convert_to_ip_address, 'collector.newrelic.com')
+    assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
   end
 
   class FakeResolv
@@ -120,7 +122,7 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     old_ipsocket = IPSocket
     Object.instance_eval { remove_const :Resolv}
     Object.instance_eval {remove_const:'IPSocket' }
-    assert_equal(nil, c.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+    assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
 
     Object.instance_eval {const_set('Resolv', old_resolv); const_set('IPSocket', old_ipsocket)}
     # these are here to make sure that the constant tomfoolery above
@@ -129,12 +131,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert_equal old_ipsocket, IPSocket
   end
 
-
-
   def test_config_yaml_erb
-    assert_equal 'heyheyhey', c['erb_value']
-    assert_equal '', c['message']
-    assert_equal '', c['license_key']
+    assert_equal 'heyheyhey', control['erb_value']
+    assert_equal '', control['message']
+    assert_equal '', control['license_key']
   end
 
   def test_appnames
@@ -142,22 +142,25 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_config_booleans
-    assert_equal c['tval'], true
-    assert_equal c['fval'], false
-    assert_nil c['not_in_yaml_val']
-    assert_equal c['yval'], true
-    assert_equal c['sval'], 'sure'
+    assert_equal control['tval'], true
+    assert_equal control['fval'], false
+    assert_nil control['not_in_yaml_val']
+    assert_equal control['yval'], true
+    assert_equal control['sval'], 'sure'
   end
+
   def test_config_apdex
-    assert_equal 1.1, c.apdex_t
+    assert_equal 1.1, control.apdex_t
   end
+
 #  def test_transaction_threshold
 #    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
 #    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
 #  end
+
   def test_log_file_name
     NewRelic::Control.instance.setup_log
-    assert_match /newrelic_agent.log$/, c.instance_variable_get('@log_file')
+    assert_match /newrelic_agent.log$/, control.instance_variable_get('@log_file')
   end
 
 #  def test_transaction_threshold__apdex
@@ -167,26 +170,84 @@ class NewRelic::ControlTest < Test::Unit::TestCase
 #  end
 
   def test_transaction_threshold__default
-
     forced_start :transaction_tracer => { :transaction_threshold => nil}
-    assert_nil c['transaction_tracer']['transaction_threshold']
+    assert_nil control['transaction_tracer']['transaction_threshold']
     assert_equal 2.0, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
   end
 
   def test_transaction_threshold__override
     forced_start :transaction_tracer => { :transaction_threshold => 1}
-    assert_equal 1, c['transaction_tracer']['transaction_threshold']
+    assert_equal 1, control['transaction_tracer']['transaction_threshold']
     assert_equal 1, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
   end
+
+  def test_transaction_tracer_disabled
+    forced_start(:transaction_tracer => { :enabled => false },
+                 :developer_mode => false, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_transaction_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
+           'transaction tracer enabled when config calls for disabled')
+    
+    @control['developer_mode'] = true
+    @control['monitor_mode'] = false
+  end
+  
+  def test_sql_tracer_disabled
+    forced_start(:slow_sql => { :enabled => false }, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql tracer enabled when config calls for disabled')
+    
+    @control['monitor_mode'] = false
+  end
+  
+  def test_sql_tracer_disabled_with_record_sql_false
+    forced_start(:slow_sql => { :enabled => true, :record_sql => 'off' })
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql tracer enabled when config calls for disabled')
+  end
+
+  def test_sql_tracer_disabled_when_tt_disabled
+    forced_start(:transaction_tracer => { :enabled => false },
+                 :slow_sql => { :enabled => true },
+                 :developer_mode => false, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql enabled when transaction tracer disabled')
+    
+    @control['developer_mode'] = true
+    @control['monitor_mode'] = false    
+  end
+
+  def test_sql_tracer_disabled_when_tt_disabled_by_server
+    forced_start(:slow_sql => { :enabled => true },
+                 :transaction_tracer => { :enabled => true },
+                 :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    NewRelic::Agent::Agent.instance.finish_setup('collect_traces' => false)    
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql enabled when tracing disabled by server')
+    
+    @control['monitor_mode'] = false        
+  end
+
   def test_merging_options
     NewRelic::Control.send :public, :merge_options
-    @c.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
+    @control.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
     assert_equal 66, NewRelic::Control.instance['api_port']
     assert_equal 2.0, NewRelic::Control.instance['transaction_tracer']['explain_threshold']
     assert_equal 'raw', NewRelic::Control.instance['transaction_tracer']['record_sql']
   end
+    
   private
-  def forced_start overrides = {}
+
+  def forced_start(overrides={})
     NewRelic::Agent.manual_start overrides
     # This is to force the agent to start again.
     NewRelic::Agent.instance.stubs(:started?).returns(nil)

data/test/new_relic/delayed_job_injection_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+
+class NewRelic::DelayedJobInstrumentationTest < Test::Unit::TestCase
+  def test_skip_logging_if_no_logger_found
+    Object.const_set('Delayed', Module.new) unless defined?(Delayed)
+    ::Delayed.const_set('Worker', Class.new) unless defined?(::Delayed::Worker)
+    
+    # on JRuby we need to make sure the worker isn't running, it might
+    # try to log
+    worker = NewRelic::Agent.agent.instance_variable_get(:@worker_loop)
+    worker.stop if worker
+    
+    NewRelic::Agent.stubs(:logger).raises(NoMethodError,
+                                          'temporarily not allowed')
+    NewRelic::Agent.stubs(:respond_to?).with(:logger).returns(false)
+    
+    assert DependencyDetection.detect!
+    
+    Object.class_eval { remove_const('Delayed') }
+  end
+end

data/test/new_relic/fake_collector.rb

@@ -0,0 +1,210 @@
+require 'rubygems'
+require 'rack'
+require 'uri'
+require 'socket'
+require 'timeout'
+require 'ostruct'
+
+module NewRelic
+  class FakeCollector
+    attr_accessor :agent_data, :mock
+    
+    def initialize
+      @id_counter = 0
+      @base_expectations = {
+        'get_redirect_host'       => 'localhost',
+        'connect'                 => { 'agent_run_id' => agent_run_id },
+        'metric_data'             => { 'Some/Metric/Spec' => 1 },
+        'sql_trace_data'          => nil,
+        'transaction_sample_data' => nil,
+        'error_data'              => nil,
+        'shutdown'                => nil,
+      }
+      reset
+    end
+
+    def agent_run_id
+      @id_counter += 1
+    end
+    
+    def call(env)
+      req = ::Rack::Request.new(env)
+      res = ::Rack::Response.new
+      uri = URI.parse(req.url)
+      if uri.path =~ /agent_listener\/\d+\/.+\/(\w+)/
+        method = $1
+        if @mock.keys.include? method
+          res.write Marshal.dump(@mock[method])
+        else
+          res.status = 500
+          res.write "Method not found"
+        end
+        run_id = uri.query =~ /run_id=(\d+)/ ? $1 : nil
+        req.body.rewind
+        @agent_data << OpenStruct.new(:action => method,
+                                      :body   => Marshal.load(req.body.read),
+                                      :run_id => run_id)
+      end
+      res.finish
+    end
+
+    def run(port=30303)
+      if is_port_available?('127.0.0.1', port)
+        @thread = Thread.new do
+          ::Rack::Handler::WEBrick.run(self, :Port => port)
+        end
+        loop do
+          break if !is_port_available?('127.0.0.1', port)
+          sleep 0.01
+        end
+      end
+    end
+
+    def stop
+      ::Rack::Handler::WEBrick.shutdown
+      @thread.join
+    end
+
+    def reset
+      @mock = @base_expectations.dup
+      @id_counter = 0
+      @agent_data = []
+    end
+    
+    def is_port_available?(ip, port)
+      begin
+        Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new(ip, port)
+            s.close
+            return false
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return true
+          end
+        end
+      rescue Timeout::Error
+      end
+      
+      return true
+    end
+  end
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+  require 'net/http'
+  
+  class FakeCollectorTest < Test::Unit::TestCase
+    def setup
+      @collector = NewRelic::FakeCollector.new
+      @collector.run
+    end
+
+    def teardown
+      @collector.stop
+    end
+    
+    def test_get_redirect
+      @collector.mock['get_redirect_host'] = 'test.example.com'
+      response = invoke('get_redirect_host')
+      
+      assert_equal 'test.example.com', response
+      assert_equal 'get_redirect_host', @collector.agent_data[0].action
+    end
+    
+    def test_connect
+      response = invoke('connect')
+      
+      assert_equal 1, response['agent_run_id']
+      assert_equal 'connect', @collector.agent_data[0].action
+    end
+
+    def test_metric_data
+      response = invoke('metric_data?run_id=1',
+                        {'Foo/Bar' => [1,2,3], 'Baz/Cux' => [4,5,6]})
+      
+      assert_equal 1, response['Some/Metric/Spec']
+      post = @collector.agent_data[0]
+      assert_equal 'metric_data', post.action
+      assert_equal({'Foo/Bar' => [1,2,3], 'Baz/Cux' => [4,5,6]}, post.body)
+      assert_equal 1, post.run_id.to_i
+    end
+
+    def test_sql_trace_data
+      response = invoke('sql_trace_data?run_id=2',
+                        ['trace', 'trace', 'trace'])
+
+      assert_nil response
+      post = @collector.agent_data[0]
+      assert_equal 'sql_trace_data', post.action
+      assert_equal ['trace', 'trace', 'trace'], post.body
+      assert_equal 2, post.run_id.to_i
+    end
+
+    def test_transaction_sample_data
+      response = invoke('transaction_sample_data?run_id=3',
+                        ['node', ['node', 'node'], 'node'])
+
+      assert_nil response
+      post = @collector.agent_data[0]
+      assert_equal 'transaction_sample_data', post.action
+      assert_equal ['node', ['node', 'node'], 'node'], post.body
+      assert_equal 3, post.run_id.to_i
+    end
+    
+    def test_error_data
+      response = invoke('error_data?run_id=4', ['error'])
+      
+      assert_nil response
+      post = @collector.agent_data[0]
+      assert_equal 'error_data', post.action
+      assert_equal ['error'], post.body
+    end
+    
+    def test_shutdown
+      response = invoke('shutdown?run_id=1')
+
+      assert_nil response
+      assert_equal 'shutdown', @collector.agent_data[0].action
+    end
+
+    def test_multiple_invokations
+      pid = Process.fork do
+        invoke('get_redirect_host')
+        invoke('connect')
+        invoke('metric_data?run_id=1')
+        invoke('transaction_sample_data?run_id=1')
+        invoke('shutdown?run_id=1')
+      end
+      invoke('get_redirect_host')
+      invoke('connect')
+      invoke('metric_data?run_id=2')
+      invoke('transaction_sample_data?run_id=2')
+      invoke('shutdown?run_id=2')
+
+      Process.wait(pid)
+      
+      expected = ['get_redirect_host', 'connect', 'metric_data',
+                  'transaction_sample_data', 'shutdown',
+                  'get_redirect_host', 'connect', 'metric_data',
+                  'transaction_sample_data', 'shutdown']
+      assert_equal expected.sort, @collector.agent_data.map(&:action).sort
+    end
+
+    def test_reset
+      @collector.mock['get_redirect_host'] = 'never!'
+      @collector.reset
+      assert_equal 'localhost', @collector.mock['get_redirect_host']
+    end
+   
+    def invoke(method, post={}, code=200)
+      uri = URI.parse("http://127.0.0.1:30303/agent_listener/8/12345/#{method}")
+      request = Net::HTTP::Post.new("#{uri.path}?#{uri.query}")
+      request.body = Marshal.dump(post)
+      response = Net::HTTP.start(uri.host, uri.port) do |http|
+        http.request(request)
+      end
+      Marshal.load(response.body)
+    end
+  end
+end