sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/command/deployments_test.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../../test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__),'/../../../lib/new_relic/command'))
+
+class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
+
+  def setup
+    NewRelic::Command::Deployments.class_eval do
+      attr_accessor :messages, :exit_status, :errors, :revision
+      def err(message); @errors = @errors ? @errors + message : message; end
+      def info(message); @messages = @messages ? @messages + message : message; end
+      def just_exit(status=0); @exit_status ||= status; end
+    end
+    @config = { :license_key => 'a' * 40 }
+    NewRelic::Agent.config.apply_config(@config)
+  end
+  def teardown
+    super
+    return unless @deployment
+    puts @deployment.errors
+    puts @deployment.messages
+    puts @deployment.exit_status
+    NewRelic::Agent.config.remove_config(@config)
+  end
+  def test_help
+    begin
+      NewRelic::Command::Deployments.new "-h"
+      fail "should have thrown"
+    rescue NewRelic::Command::CommandFailure => c
+      assert_match /^Usage/, c.message
+    end
+  end
+  def test_bad_command
+    assert_raise NewRelic::Command::CommandFailure do
+      NewRelic::Command::Deployments.new ["-foo", "bar"]
+    end
+  end
+  def test_interactive
+    mock_the_connection
+    @deployment = NewRelic::Command::Deployments.new(:appname => 'APP',
+                                  :revision => 3838,
+                                  :user => 'Bill',
+                                  :description => "Some lengthy description")
+    assert_nil @deployment.exit_status
+    assert_nil @deployment.errors
+    assert_equal '3838', @deployment.revision
+    @deployment.run
+    @deployment = nil
+  end
+
+  def test_command_line_run
+    mock_the_connection
+    #    @mock_response.expects(:body).returns("<xml>deployment</xml>")
+    @deployment = NewRelic::Command::Deployments.new(%w[-a APP -r 3838 --user=Bill] << "Some lengthy description")
+    assert_nil @deployment.exit_status
+    assert_nil @deployment.errors
+    assert_equal '3838', @deployment.revision
+    @deployment.run
+
+    # This should pass because it's a bogus deployment
+    #assert_equal 1, @deployment.exit_status
+    #assert_match /Unable to upload/, @deployment.errors
+
+    @deployment = nil
+  end
+
+  def test_error_if_no_license_key
+    with_config(:license_key => '') do
+      assert_raise NewRelic::Command::CommandFailure do
+      deployment = NewRelic::Command::Deployments.new(%w[-a APP -r 3838 --user=Bill] << "Some lengthy description")
+        deployment.run
+      end
+    end
+  end
+
+  private
+
+  def mock_the_connection
+    mock_connection = mock()
+    @mock_response = mock()
+    @mock_response.expects(:is_a?).with(Net::HTTPSuccess).returns(true)
+    mock_connection.expects(:request).returns(@mock_response)
+    NewRelic::Agent::NewRelicService.any_instance.stubs(:http_connection).returns(mock_connection)
+  end
+end

data/test/new_relic/control/class_methods_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/control/class_methods'
+
+class BaseClassMethods
+  # stub class to enable testing of the module
+  include NewRelic::Control::ClassMethods
+end
+
+class NewRelic::Control::ClassMethodsTest < Test::Unit::TestCase
+  def setup
+    @base = ::BaseClassMethods.new
+    super
+  end
+
+  def test_instance
+    assert_equal(nil, @base.instance_variable_get('@instance'), 'instance should start out nil')
+    @base.expects(:new_instance).returns('a new instance')
+    assert_equal('a new instance', @base.instance, "should return the result from the #new_instance call")
+  end
+
+  def test_load_test_framework
+    local_env = mock('local env')
+    # a loose requirement here because the tests will *all* break if
+    # this does not work.
+    NewRelic::Control::Frameworks::Test.expects(:new).with(local_env, instance_of(String))
+    @base.expects(:local_env).returns(local_env)
+    @base.load_test_framework
+  end
+
+  def test_load_framework_class_existing
+    %w[rails rails3 sinatra ruby merb external].each do |type|
+      @base.load_framework_class(type)
+    end
+  end
+  
+  def test_load_framework_class_missing
+    # this is used to allow other people to insert frameworks without
+    # having the file in our agent, i.e. define your own
+    # NewRelic::Control::Framework::FooBar
+    assert_raise(NameError) do
+      @base.load_framework_class('missing')
+    end
+  end
+end

data/test/new_relic/control/frameworks/rails_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../../../test_helper'))
+
+class NewRelic::Control::Frameworks::RailsTest < Test::Unit::TestCase
+  def test_install_browser_monitoring
+    require(File.expand_path(File.join(File.dirname(__FILE__),
+                         '/../../../../lib/new_relic/rack/browser_monitoring')))
+    middleware = stub('middleware config')
+    config = stub('rails config', :middleware => middleware)
+    middleware.expects(:use).with(NewRelic::Rack::BrowserMonitoring)
+    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
+    with_config(:'browser_monitoring.auto_instrument' => true) do
+      NewRelic::Control.instance.install_browser_monitoring(config)
+    end
+  end
+
+  def test_install_browser_monitoring_should_not_install_when_not_configured
+    middleware = stub('middleware config')
+    config = stub('rails config', :middleware => middleware)
+    middleware.expects(:use).never
+    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
+
+    with_config(:'browser_monitoring.auto_instrument' => false) do
+      NewRelic::Control.instance.install_browser_monitoring(config)
+    end
+  end
+end

data/test/new_relic/control_test.rb

@@ -0,0 +1,194 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
+
+class NewRelic::ControlTest < Test::Unit::TestCase
+  attr_reader :control
+
+  def setup
+    @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_test_config
+    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+      assert_equal :rails4, control.app
+    elsif defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+      assert_equal :rails3, control.app
+    elsif defined?(::Rails)
+      assert_equal :rails, control.app
+    else
+      assert_equal :test, control.app
+    end
+    assert_equal :test, control.framework
+    assert_match /test/i, control.local_env.dispatcher_instance_id
+    assert("" == NewRelic::Agent.config[:dispatcher].to_s,
+           "Expected dispatcher to be empty, but was #{NewRelic::Agent.config[:dispatcher].to_s}")
+    assert !NewRelic::Agent.config[:monitor_mode]
+    control.local_env
+  end
+
+  def test_settings_accessor
+    assert_not_nil control.settings
+  end
+
+  def test_root
+    assert File.directory?(NewRelic::Control.newrelic_root), NewRelic::Control.newrelic_root
+    if defined?(Rails)
+      assert File.directory?(File.join(NewRelic::Control.newrelic_root, "lib")), NewRelic::Control.newrelic_root +  "/lib"
+    end
+  end
+
+  def test_info
+    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
+    props = NewRelic::Control.instance.local_env.snapshot
+    if defined?(Rails)
+      assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last, props.inspect
+    end
+  end
+
+  def test_resolve_ip_for_localhost
+    with_config(:ssl => false, :verify_certificate => false) do
+      assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    end
+  end
+
+  def test_resolve_ip_for_non_existent_domain
+    with_config(:ssl => false, :verify_certificate => false) do
+      Resolv.stubs(:getaddress).raises(Resolv::ResolvError)
+      IPSocket.stubs(:getaddress).raises(SocketError)
+      assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
+    end
+  end
+
+  def test_resolves_valid_ip
+    with_config(:ssl => false, :verify_certificate => false) do
+      Resolv.stubs(:getaddress).with('collector.newrelic.com').returns('204.93.223.153')
+      assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
+    end
+  end
+
+  def test_do_not_resolve_if_we_need_to_verify_a_cert
+    with_config(:ssl => false, :verify_certificate => false) do
+      assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    end
+    with_config(:ssl => true, :verify_certificate => true) do
+      assert_equal 'localhost', control.send(:convert_to_ip_address, 'localhost')
+    end
+  end
+
+  def test_api_server_uses_configured_values
+    control.instance_variable_set(:@api_server, nil)
+    with_config(:api_host => 'somewhere', :api_port => 8080) do
+      assert_equal 'somewhere', control.api_server.name
+      assert_equal 8080, control.api_server.port
+    end
+  end
+
+  def test_proxy_server_uses_configured_values
+    control.instance_variable_set(:@proxy_server, nil)
+    with_config(:proxy_host => 'proxytown', :proxy_port => 81) do
+      assert_equal 'proxytown', control.proxy_server.name
+      assert_equal 81, control.proxy_server.port
+    end
+  end
+
+  def test_server_from_host_uses_configured_values
+    with_config(:host => 'donkeytown', :port => 8080) do
+      assert_equal 'donkeytown', control.server_from_host.name
+      assert_equal 8080, control.server_from_host.port
+    end
+  end
+
+  class FakeResolv
+    def self.getaddress(host)
+      raise 'deliberately broken'
+    end
+  end
+
+  def test_resolve_ip_with_broken_dns
+    # Here be dragons: disable the ruby DNS lookup methods we use so
+    # that it will actually fail to resolve.
+    old_resolv = Resolv
+    old_ipsocket = IPSocket
+    Object.instance_eval { remove_const :Resolv}
+    Object.instance_eval {remove_const:'IPSocket' }
+
+    with_config(:ssl => false, :verify_certificate => false) do
+      assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+    end
+
+    Object.instance_eval {const_set('Resolv', old_resolv); const_set('IPSocket', old_ipsocket)}
+    # these are here to make sure that the constant tomfoolery above
+    # has not broket the system unduly
+    assert_equal old_resolv, Resolv
+    assert_equal old_ipsocket, IPSocket
+  end
+
+  def test_transaction_threshold__override
+    with_config(:transaction_tracer => { :transaction_threshold => 1}) do
+      assert_equal 1, NewRelic::Agent.config[:'transaction_tracer.transaction_threshold']
+    end
+  end
+
+  def test_transaction_tracer_disabled
+    with_config(:'transaction_tracer.enabled' => false,
+                :developer_mode => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
+             'transaction tracer enabled when config calls for disabled')
+    end
+  end
+
+  def test_sql_tracer_disabled
+    with_config(:'slow_sql.enabled' => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql tracer enabled when config calls for disabled')
+    end
+  end
+
+  def test_sql_tracer_disabled_with_record_sql_false
+    with_config(:slow_sql => { :enabled => true, :record_sql => 'off' }) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql tracer enabled when config calls for disabled')
+    end
+  end
+
+  def test_sql_tracer_disabled_when_tt_disabled
+    with_config(:'transaction_tracer.enabled' => false,
+                :'slow_sql.enabled' => true,
+                :developer_mode => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql enabled when transaction tracer disabled')
+    end
+  end
+
+  def test_sql_tracer_disabled_when_tt_disabled_by_server
+    with_config({:'slow_sql.enabled' => true,
+                  :'transaction_tracer.enabled' => true,
+                  :monitor_mode => true}, :level => 2) do
+      NewRelic::Agent.instance.finish_setup('collect_traces' => false)
+
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql enabled when tracing disabled by server')
+    end
+  end
+
+  def test_init_plugin_loads_samplers_enabled
+    NewRelic::Agent.shutdown
+    with_config(:disable_samplers => false, :agent_enabled => true) do
+      NewRelic::Control.instance.init_plugin
+      assert NewRelic::Agent.instance.stats_engine.send(:harvest_samplers).any?
+    end
+  end
+
+  def test_init_plugin_loads_samplers_disabled
+    NewRelic::Agent.shutdown
+    with_config(:disable_samplers => true, :agent_enabled => true) do
+      NewRelic::Control.instance.init_plugin
+      assert NewRelic::Agent.instance.stats_engine.send(:harvest_samplers).empty?
+    end
+  end
+end

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/dispatcher_test.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+
+# Test logic around detecting or configuring dispatcher
+class DispatcherTest < Test::Unit::TestCase
+
+  def setup
+    NewRelic::Agent.shutdown
+    NewRelic::Agent.reset_config
+  end
+
+  def assert_dispatcher_reported_to_environment_report(dispatcher)
+    NewRelic::Control.instance.local_env.gather_environment_info
+    key, value = NewRelic::Control.instance.local_env.snapshot.detect do |(k, v)|
+      k == "Dispatcher"
+    end
+    assert_equal dispatcher.to_s, value
+  end
+
+  def test_detects_dispatcher_via_loaded_libraries
+    class << self
+      module ::PhusionPassenger
+      end
+    end
+    assert_equal :passenger, NewRelic::Agent.config[:dispatcher]
+    assert_dispatcher_reported_to_environment_report :passenger
+  ensure
+    Object.send(:remove_const, :PhusionPassenger)
+  end
+
+  def test_detects_dispatcher_via_ENV_NEW_RELIC_DISPATCHER
+    ENV['NEW_RELIC_DISPATCHER'] = "foobared"
+    NewRelic::Agent.reset_config
+    assert_equal :foobared, NewRelic::Agent.config[:dispatcher]
+    assert_dispatcher_reported_to_environment_report :foobared
+  ensure
+    ENV['NEW_RELIC_DISPATCHER'] = nil
+  end
+
+  def test_detects_dispatcher_via_ENV_NEWRELIC_DISPATCHER
+    ENV['NEWRELIC_DISPATCHER'] = "bazbang"
+    NewRelic::Agent.reset_config
+    assert_equal :bazbang, NewRelic::Agent.config[:dispatcher]
+    assert_dispatcher_reported_to_environment_report :bazbang
+  ensure
+    ENV['NEWRELIC_DISPATCHER'] = nil
+  end
+
+  def test_detects_dispatcher_based_on_arguments_to_manual_start
+    NewRelic::Agent.manual_start(:dispatcher   => :resque)
+    assert_equal :resque, NewRelic::Agent.config[:dispatcher]
+    assert_dispatcher_reported_to_environment_report :resque
+  end
+
+end

data/test/new_relic/fake_collector.rb

@@ -0,0 +1,389 @@
+require 'rubygems'
+require 'rack'
+require 'uri'
+require 'socket'
+require 'timeout'
+require 'ostruct'
+
+require 'json' if RUBY_VERSION >= '1.9'
+
+module NewRelic
+  class FakeCollector
+    attr_accessor :agent_data, :mock
+
+    def initialize
+      @id_counter = 0
+      @base_expectations = {
+        'get_redirect_host'       => [200, {'return_value' => 'localhost'}],
+        'connect'                 => [200, {'return_value' => {"agent_run_id" => agent_run_id}}],
+        'get_agent_commands'      => [200, {'return_value' => []}],
+        'metric_data'             => [200, {'return_value' => [[{'name' => 'Some/Metric/Spec'}, 1]]}],
+        'sql_trace_data'          => [200, {'return_value' => nil}],
+        'transaction_sample_data' => [200, {'return_value' => nil}],
+        'error_data'              => [200, {'return_value' => nil}],
+        'shutdown'                => [200, {'return_value' => 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
+        format = json_format?(uri) && RUBY_VERSION >= '1.9' ? :json : :pruby
+        if @mock.keys.include? method
+          res.status = @mock[method][0]
+          if format == :json
+            res.write JSON.dump(@mock[method][1])
+          else
+            res.write Marshal.dump(@mock[method][1])
+          end
+        else
+          res.status = 500
+          res.write "Method not found"
+        end
+        run_id = uri.query =~ /run_id=(\d+)/ ? $1 : nil
+        req.body.rewind
+
+        body = if format == :json
+          body = JSON.load(req.body.read)
+        else
+          body = Marshal.load(req.body.read)
+        end
+        @agent_data << AgentPost.create(:action       => method,
+                                        :body         => body,
+                                        :run_id       => run_id,
+                                        :format       => format)
+      end
+      res.finish
+    end
+
+    def json_format?(uri)
+      uri.query && uri.query.include?('marshal_format=json')
+    end
+
+    # We generate a "unique" port for ourselves based off our pid
+    # If this logic changes, look for multiverse newrelic.yml files to update
+    # with it duplicated (since we can't easily pull this ruby into a yml)
+    def self.determine_port
+      30_000 + ($$ % 10_000)
+    end
+
+    def determine_port
+      FakeCollector.determine_port
+    end
+
+    @seen_port_failure = false
+
+    def run(port=nil)
+      port ||= determine_port
+      return if @thread && @thread.alive?
+      serve_on_port(port) do
+        @thread = Thread.new do
+          begin
+          ::Rack::Handler::WEBrick.run(self,
+                                       :Port => port,
+                                       :Logger => ::WEBrick::Log.new("/dev/null"),
+                                       :AccessLog => [ ['/dev/null', ::WEBrick::AccessLog::COMMON_LOG_FORMAT] ]
+                                      )
+          rescue Errno::EADDRINUSE => ex
+            msg = "Port #{port} for FakeCollector was in use"
+            if !@seen_port_failure
+              # This is slow, so only do it the first collision we detect
+              lsof = `lsof | grep #{port}`
+              msg = msg + "\n#{lsof}"
+              @seen_port_failure = true
+            end
+
+            raise Errno::EADDRINUSE.new(msg)
+          end
+        end
+        @thread.abort_on_exception = true
+      end
+    end
+
+    def serve_on_port(port)
+      port ||= determine_port
+      if is_port_available?('127.0.0.1', port)
+        yield
+        loop do
+          break if !is_port_available?('127.0.0.1', port)
+          sleep 0.01
+        end
+      end
+    end
+
+    def stop
+      return unless @thread.alive?
+      ::Rack::Handler::WEBrick.shutdown
+      @thread.join
+      reset
+    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
+
+    def calls_for(method)
+      @agent_data.select {|d| d.action == method }
+    end
+
+    def reported_stats_for_metric(name, scope=nil)
+      calls_for('metric_data').map do |post|
+        post.body[3].find do |metric_record|
+          metric_record[0]['name'] == name &&
+            (!scope || metric_record[0]['scope'] == scope)
+        end
+      end.compact.map{|m| m[1]}
+    end
+
+    class AgentPost
+      attr_accessor :action, :body, :run_id, :format
+      def initialize(opts={})
+        @action = opts[:action]
+        @body   = opts[:body]
+        @run_id = opts[:run_id]
+        @format = opts[:format]
+      end
+
+      def self.create(opts={})
+        case opts[:action]
+        when 'connect'
+          ConnectPost.new(opts)
+        when 'metric_data'
+          AgentPost.new(opts)
+        when 'profile_data'
+          ProfileDataPost.new(opts)
+        when 'sql_trace_data'
+          SqlTraceDataPost.new(opts)
+        when 'transaction_sample_data'
+          TransactionSampleDataPost.new(opts)
+        else
+          new(opts)
+        end
+      end
+
+      def [](key)
+        @body[key]
+      end
+
+      def unblob(blob)
+        return unless blob
+        JSON.load(Zlib::Inflate.inflate(Base64.decode64(blob)))
+      end
+    end
+
+    class ConnectPost < AgentPost
+      def initialize(opts={})
+        super
+        @body = @body[0]
+      end
+    end
+
+    class ProfileDataPost < AgentPost
+      def initialize(opts={})
+        super
+        @body[1][0][4] = unblob(@body[1][0][4]) if @format == :json
+      end
+    end
+
+    class SqlTraceDataPost < AgentPost
+      def initialize(opts={})
+        super
+        @body[0][0][9] = unblob(@body[0][0][9]) if @format == :json
+      end
+    end
+
+    class TransactionSampleDataPost < AgentPost
+      def initialize(opts={})
+        super
+        @body[4] = unblob(@body[4]) if @format == :json
+      end
+
+      def metric_name
+        @body[1][0][2]
+      end
+    end
+  end
+
+  # might we need this?  I'll just leave it here for now
+  class FakeCollectorProcess < FakeCollector
+    def run(port)
+      serve_on_port(port) do
+        @pid = Process.fork do
+          ::Rack::Handler::WEBrick.run(self, :Port => port)
+        end
+      end
+    end
+
+    def stop
+      return unless @pid
+      Process.kill('QUIT', @pid)
+      Process.wait(@pid)
+    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'] = [200, '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_transaction_sample_data_json
+      response = invoke('transaction_sample_data?run_id=3&marshal_format=json',
+                        '["node",["node","node"],"node"]')
+
+      assert_equal '', 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'] = [200, 'never!']
+      @collector.reset
+      assert_equal [200, 'localhost'], @collector.mock['get_redirect_host']
+    end
+
+    def invoke(method, post={}, code=200)
+      uri = URI.parse("http://127.0.0.1:#{@collector.determine_port}/agent_listener/8/12345/#{method}")
+      request = Net::HTTP::Post.new("#{uri.path}?#{uri.query}")
+      if uri.query && uri.query.include?('marshal_format=json')
+        request.body = JSON.dump(post)
+      else
+        request.body = Marshal.dump(post)
+      end
+      response = Net::HTTP.start(uri.host, uri.port) do |http|
+        http.request(request)
+      end
+      if uri.query && uri.query.include?('marshal_format=json')
+        JSON.load(response.body)
+      else
+        Marshal.load(response.body)
+      end
+    end
+  end
+end
+