dolores_rpm 3.2.0.2

data/test/new_relic/agent/agent/start_worker_thread_test.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
+  require 'new_relic/agent/agent'
+  include NewRelic::Agent::Agent::StartWorkerThread
+
+  def test_deferred_work_connects
+    self.expects(:catch_errors).yields
+    self.expects(:connect).with('connection_options')
+    @connected = true
+    self.expects(:check_transaction_sampler_status)
+    self.expects(:check_sql_sampler_status)    
+    self.expects(:log_worker_loop_start)
+    self.expects(:create_and_run_worker_loop)
+    deferred_work!('connection_options')
+  end
+
+  def test_deferred_work_connect_failed
+    self.expects(:catch_errors).yields
+    self.expects(:connect).with('connection_options')
+    @connected = false
+    fake_log = mocked_log
+    fake_log.expects(:debug).with("No connection.  Worker thread ending.")
+    deferred_work!('connection_options')
+  end
+
+  def test_check_transaction_sampler_status_enabled
+    control = mocked_control
+    control.expects(:developer_mode?).returns(false)
+    @should_send_samples = true
+    @transaction_sampler = mock('transaction_sampler')
+    @transaction_sampler.expects(:enable)
+    check_transaction_sampler_status
+  end
+
+  def test_check_transaction_sampler_status_devmode
+    control = mocked_control
+    control.expects(:developer_mode?).returns(true)
+    @should_send_samples = false
+    @transaction_sampler = mock('transaction_sampler')
+    @transaction_sampler.expects(:enable)
+    check_transaction_sampler_status
+  end
+
+  def test_check_transaction_sampler_status_disabled
+    control = mocked_control
+    control.expects(:developer_mode?).returns(false)
+    @should_send_samples = false
+    @transaction_sampler = mock('transaction_sampler')
+    @transaction_sampler.expects(:disable)
+    check_transaction_sampler_status
+  end
+
+  def test_log_worker_loop_start
+    @report_period = 30
+    log = mocked_log
+    log.expects(:info).with("Reporting performance data every 30 seconds.")
+    log.expects(:debug).with("Running worker loop")
+    log_worker_loop_start
+  end
+
+  def test_create_and_run_worker_loop
+    @report_period = 30
+    @should_send_samples = true
+    wl = mock('worker loop')
+    NewRelic::Agent::WorkerLoop.expects(:new).returns(wl)
+    wl.expects(:run).with(30).yields
+    self.expects(:save_or_transmit_data)
+    create_and_run_worker_loop
+  end
+
+  def test_handle_force_restart
+    # hooray for methods with no branches
+    error = mock('exception')
+    log = mocked_log
+    error.expects(:message).returns('a message')
+    log.expects(:info).with('a message')
+    self.expects(:reset_stats)
+    self.expects(:sleep).with(30)
+
+    @metric_ids = 'this is not an empty hash'
+    @connected = true
+
+    handle_force_restart(error)
+
+    assert_equal({}, @metric_ids)
+    assert @connected.nil?
+  end
+
+  def test_handle_force_disconnect
+    error = mock('exception')
+    error.expects(:message).returns('a message')
+    log = mocked_log
+    log.expects(:error).with("New Relic forced this agent to disconnect (a message)")
+    self.expects(:disconnect)
+    handle_force_disconnect(error)
+  end
+
+  def test_handle_server_connection_problem
+    error_class = mock('class of exception')
+    error = mock('exception')
+    log = mocked_log
+    log.expects(:error).with('Unable to establish connection with the server.  Run with log level set to debug for more information.')
+    error.expects(:class).returns(error_class)
+    error_class.expects(:name).returns('an error class')
+    error.expects(:message).returns('a message')
+    error.expects(:backtrace).returns(['first line', 'second line'])
+    log.expects(:debug).with("an error class: a message\nfirst line")
+    self.expects(:disconnect)
+    handle_server_connection_problem(error)
+  end
+
+  def test_handle_other_error
+    error_class = mock('class of exception')
+    error = mock('exception')
+    log = mocked_log
+    error.expects(:class).returns(error_class)
+    error_class.expects(:name).returns('an error class')
+    error.expects(:message).returns('a message')
+    error.expects(:backtrace).returns(['first line', 'second line'])
+    log.expects(:error).with("Terminating worker loop: an error class: a message\n  first line\n  second line")
+    self.expects(:disconnect)
+    handle_other_error(error)
+  end
+
+  def test_catch_errors_force_restart
+    @runs = 0
+    error = NewRelic::Agent::ForceRestartException.new
+    # twice, because we expect it to retry the block
+    self.expects(:handle_force_restart).with(error).twice
+    catch_errors do
+      # needed to keep it from looping infinitely in the test
+      @runs += 1
+      raise error unless @runs > 2
+    end
+    assert_equal 3, @runs, 'should retry the block when it fails'
+  end
+
+  private
+
+  def mocked_log
+    fake_log = mock('log')
+    self.stubs(:log).returns(fake_log)
+    fake_log
+  end
+
+
+  def mocked_control
+    fake_control = mock('control')
+    self.stubs(:control).returns(fake_control)
+    fake_control
+  end
+end
+

data/test/new_relic/agent/agent_test.rb

@@ -0,0 +1,139 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+module NewRelic
+  module Agent
+    class AgentTest < Test::Unit::TestCase
+
+      def setup
+        super
+        @agent = NewRelic::Agent::Agent.new
+      end
+
+      def test_save_or_transmit_data_should_save
+        NewRelic::Agent.expects(:save_data).once
+        @agent.expects(:harvest_and_send_timeslice_data).never
+        NewRelic::DataSerialization.expects(:should_send_data?).returns(false)
+        @agent.instance_eval { save_or_transmit_data }
+      end
+      
+      def test_save_or_transmit_data_should_transmit
+        NewRelic::Agent.expects(:load_data)
+        @agent.expects(:harvest_and_send_timeslice_data)
+        @agent.expects(:harvest_and_send_slowest_sample)
+        @agent.expects(:harvest_and_send_errors)
+        NewRelic::DataSerialization.expects(:should_send_data?).returns(true)
+        @agent.instance_eval { save_or_transmit_data }
+      end
+      
+      def test_serialize
+        assert_equal([{}, [], []], @agent.send(:serialize), "should return nil when shut down")
+      end
+
+      def test_harvest_transaction_traces
+        assert_equal([], @agent.send(:harvest_transaction_traces), 'should return transaction traces')
+      end
+
+      def test_harvest_timeslice_data
+        assert_equal({}, @agent.send(:harvest_timeslice_data),
+                     'should return timeslice data')
+      end
+
+      def test_harvest_timelice_data_should_be_thread_safe
+        2000.times do |i|
+          @agent.stats_engine.stats_hash[i.to_s] = NewRelic::StatsBase.new
+        end
+        
+        harvest = Thread.new do
+          @agent.send(:harvest_timeslice_data)
+        end
+
+        app = Thread.new do
+          @agent.stats_engine.stats_hash["a"] = NewRelic::StatsBase.new
+        end
+        
+        assert_nothing_raised do
+          [app, harvest].each{|t| t.join}
+        end
+      end
+
+      def test_harvest_errors
+        assert_equal([], @agent.send(:harvest_errors), 'should return errors')
+      end
+
+      def test_merge_data_from_empty
+        unsent_timeslice_data = mock('unsent timeslice data')
+        unsent_errors = mock('unsent errors')
+        unsent_traces = mock('unsent traces')
+        @agent.instance_eval {
+          @unsent_errors = unsent_errors
+          @unsent_timeslice_data = unsent_timeslice_data
+          @traces = unsent_traces
+        }
+        # nb none of the others should receive merge requests
+        @agent.merge_data_from([{}])
+      end
+
+      def test_unsent_errors_size_empty
+        @agent.instance_eval {
+          @unsent_errors = nil
+        }
+        assert_equal(nil, @agent.unsent_errors_size)
+      end
+
+      def test_unsent_errors_size_with_errors
+        @agent.instance_eval {
+          @unsent_errors = ['an error']
+        }
+        assert_equal(1, @agent.unsent_errors_size)
+      end
+      
+      def test_unsent_traces_size_empty
+        @agent.instance_eval {
+          @traces = nil
+        }
+        assert_equal(nil, @agent.unsent_traces_size)
+      end
+
+      def test_unsent_traces_size_with_traces
+        @agent.instance_eval {
+          @traces = ['a trace']
+        }
+        assert_equal(1, @agent.unsent_traces_size)
+      end
+
+      def test_unsent_timeslice_data_empty
+        @agent.instance_eval {
+          @unsent_timeslice_data = nil
+        }
+        assert_equal(0, @agent.unsent_timeslice_data, "should have zero timeslice data to start")
+        assert_equal({}, @agent.instance_variable_get('@unsent_timeslice_data'), "should initialize the timeslice data to an empty hash if it is empty")
+      end
+
+      def test_unsent_timeslice_data_with_errors
+        @agent.instance_eval {
+          @unsent_timeslice_data = {:key => 'value'}
+        }
+        assert_equal(1, @agent.unsent_timeslice_data, "should have the key from above")
+      end
+      
+      def test_merge_data_from_all_three_empty
+        unsent_timeslice_data = mock('unsent timeslice data')
+        unsent_errors = mock('unsent errors')
+        unsent_traces = mock('unsent traces')
+        @agent.instance_eval {
+          @unsent_errors = unsent_errors
+          @unsent_timeslice_data = unsent_timeslice_data
+          @traces = unsent_traces
+        }
+        unsent_errors.expects(:+).with([])
+        unsent_traces.expects(:+).with([])
+        @agent.merge_data_from([{}, [], []])
+      end
+
+      def test_should_not_log_log_file_location_if_no_log_file
+        NewRelic::Control.instance.stubs(:log_file).returns('/vasrkjn4b3b4')
+        @agent.expects(:log).never
+        @agent.notify_log_file_location
+      end
+    end
+  end
+end

data/test/new_relic/agent/agent_test_controller.rb

@@ -0,0 +1,77 @@
+# Defining a test controller class with a superclass, used to
+# verify correct attribute inheritence
+class NewRelic::Agent::SuperclassController <  ActionController::Base
+  def base_action
+    render :text => 'none'
+  end
+end
+# This is a controller class used in testing controller instrumentation
+class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassController
+  # filter_parameter_logging :social_security_number
+
+  @@headers_to_add = nil
+
+  def index
+    sleep params['wait'].to_i if params['wait']
+    render :text => params.inspect
+  end
+  def _filter_parameters(params)
+    filter_parameters params
+  end
+  def action_inline
+    render(:inline => "<%= 'foo' %>fah")
+  end
+
+  def action_to_render
+    render :text => params.inspect
+  end
+  def action_to_ignore
+    render :text => 'unmeasured'
+  end
+  def action_to_ignore_apdex
+    render :text => 'unmeasured'
+  end
+  before_filter :oops, :only => :action_with_before_filter_error
+  def action_with_before_filter_error
+    render :text => 'nothing'
+  end
+  def oops
+    raise "error in before filter"
+  end
+  class TestException < RuntimeError
+  end
+
+  def rescue_action_locally(exception)
+    if exception.is_a? TestException
+      raise "error in the handler"
+    end
+  end
+  def action_with_error
+    raise "error in action"
+  end
+  def entry_action
+    perform_action_with_newrelic_trace('internal_action') do
+      internal_action
+    end
+  end
+
+  def self.set_some_headers(hash_of_headers)
+    @@headers_to_add ||= {}
+    @@headers_to_add.merge!(hash_of_headers)
+  end
+
+  def self.clear_headers
+    @@headers_to_add = nil
+  end
+
+  def newrelic_request_headers
+    @@headers_to_add ||= {}
+  end
+
+  private
+  def internal_action
+    perform_action_with_newrelic_trace(:name => 'internal_traced_action', :force => true) do
+      render :text => 'internal action'
+    end
+  end
+end