factorylabs-newrelic_rpm 2.10.2.2

data/test/new_relic/agent/worker_loop_test.rb

@@ -0,0 +1,103 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+NewRelic::Agent::WorkerLoop.class_eval do 
+  public :run_next_task
+end
+
+class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
+  def setup
+    @log = ""
+    @logger = Logger.new(StringIO.new(@log))
+    @worker_loop = NewRelic::Agent::WorkerLoop.new(@logger)
+    @test_start_time = Time.now
+  end
+  def test_add_task
+    @x = false
+    period = 1.0
+    @worker_loop.add_task(period) do
+      @x = true
+    end
+    
+    assert !@x
+    @worker_loop.run_next_task
+    assert @x
+    check_test_timestamp period
+  end
+  
+  def test_add_tasks_with_different_periods
+    @last_executed = nil
+    
+    period1 = 0.5
+    period2 = 0.7
+    
+    @worker_loop.add_task(period1) do
+      @last_executed = 1
+    end
+    
+    @worker_loop.add_task(period2) do
+      @last_executed = 2
+    end
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 1
+    check_test_timestamp(0.5)
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 2
+    check_test_timestamp(0.7)
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 1 
+    check_test_timestamp(1.0)
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 2
+    check_test_timestamp(1.4)
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 1
+    check_test_timestamp(1.5)
+  end
+  
+  def test_task_error__standard
+    @worker_loop.add_task(0.2) do
+      raise "Standard Error Test"
+    end
+    # Should not throw
+    @logger.expects(:error).once
+    @logger.expects(:debug).never
+    @worker_loop.run_next_task
+    
+  end
+  def test_task_error__runtime
+    @worker_loop.add_task(0.2) do
+      raise RuntimeError, "Runtime Error Test"
+    end
+    # Should not throw, but log at error level
+    # because it detects no agent listener inthe
+    # stack
+    @logger.expects(:error).once
+    @logger.expects(:debug).never
+    @worker_loop.run_next_task
+  end
+
+  def test_task_error__server
+    @worker_loop.add_task(0.2) do
+      raise NewRelic::Agent::ServerError, "Runtime Error Test"
+    end
+    # Should not throw
+    @logger.expects(:error).never
+    @logger.expects(:debug).once
+    @worker_loop.run_next_task
+  end
+  
+  private
+  # The test is expected to have lasted no less than expected
+  # and no more than expected + 100 ms.
+  def check_test_timestamp(expected)
+    ts = Time.now - @test_start_time
+    delta = ts - expected
+    assert(delta <= 0.250, "#{ts} duration includes a delay of #{delta} that exceeds 250 milliseconds")
+  end
+end

data/test/new_relic/control_test.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
+
+class NewRelic::ControlTest < Test::Unit::TestCase
+  
+  attr_reader :c
+  
+  def setup
+    NewRelic::Agent.manual_start
+    @c =  NewRelic::Control.instance
+  end
+  def shutdown
+    NewRelic::Agent.shutdown
+  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?
+  ensure
+    @c['enabled'] = false
+    @c['monitor_mode'] = false
+  end
+  
+  def test_test_config
+    assert_equal :rails, c.app
+    assert_equal :test, c.framework
+    assert_match /test/i, c.dispatcher_instance_id
+    assert_equal nil, c.dispatcher
+    assert !c['enabled']
+    assert_equal false, c['monitor_mode']
+    c.local_env
+  end
+  
+  def test_root
+    assert File.directory?(NewRelic::Control.newrelic_root), NewRelic::Control.newrelic_root
+    assert File.directory?(File.join(NewRelic::Control.newrelic_root, "lib")), NewRelic::Control.newrelic_root +  "/lib"
+  end
+  
+  def test_info
+    props = NewRelic::Control.instance.local_env.snapshot
+    assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last
+  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')
+    # This might fail if you don't have a valid, accessible, DNS server
+    assert_equal '65.74.177.194', c.send(:convert_to_ip_address, 'rpm.newrelic.com')
+  end
+  def test_config_yaml_erb
+    assert_equal 'heyheyhey', c['erb_value']
+    assert_equal '', c['message']
+    assert_equal '', c['license_key']
+  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'
+  end
+  def test_config_apdex
+    assert_equal 1.1, c.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
+    assert_match /newrelic_agent.log$/, c.instance_variable_get('@log_file')
+  end
+   
+  def test_transaction_threshold__apdex
+    forced_start
+    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_transaction_threshold__default
+    
+    forced_start :transaction_tracer => {}
+    assert_nil c['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, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+  end
+  private
+  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)
+    NewRelic::Agent.instance.start 
+  end
+end

data/test/new_relic/delayed_job_test.rb

@@ -0,0 +1,108 @@
+if defined? Delayed::Job
+  require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
+  
+  class LongRunningJob
+    def perform
+      sleep 5
+    end
+  end
+  
+  class NamedJob
+    def display_name
+      'some custom name'
+    end
+    def perform
+      true
+    end
+  end
+  
+  class DelayedJobTest < Test::Unit::TestCase
+    def local_env
+      NewRelic::Control.instance.local_env
+    end
+    
+    def worker_name
+      local_env.dispatcher_instance_id
+    end
+    
+    def lock_n_jobs(n=1)
+      n.times do
+        job = Delayed::Job.create
+        job.update_attributes({
+          :locked_at => Time.now,
+          :locked_by => worker_name
+        })
+      end
+    end
+    
+    def setup      
+      NewRelic::Agent.manual_start
+      @agent = NewRelic::Agent.instance
+      
+      @agent.transaction_sampler.harvest
+      @agent.stats_engine.clear_stats
+    end
+
+    def teardown
+      @agent.instance_variable_set("@histogram", NewRelic::Histogram.new)
+    end
+    
+    def test_job_instrumentation
+      job = Delayed::Job.new(:payload_object => LongRunningJob.new)
+      job_name = "Controller/Task/Delayed::Job/LongRunningJob"
+            
+      job.invoke_job
+      job_stats = @agent.stats_engine.get_stats(job_name)
+      
+      assert @agent.stats_engine.metrics.include?(job_name)
+      assert_equal 1, job_stats.call_count
+    end
+    
+    def test_custom_name
+      job = Delayed::Job.new(:payload_object => NamedJob.new)
+      job_name = "Controller/Task/Delayed::Job/some custom name"
+            
+      job.invoke_job
+      job_stats = @agent.stats_engine.get_stats(job_name)
+      
+      assert @agent.stats_engine.metrics.include?(job_name)
+      assert_equal 1, job_stats.call_count
+    end
+    
+    def test_lock_sampler
+      stats_engine = NewRelic::Agent::StatsEngine.new
+      sampler = NewRelic::Agent::Samplers::DelayedJobLockSampler.new
+      sampler.stats_engine = stats_engine
+            
+      lock_n_jobs(1)
+      sampler.poll
+      
+      assert_equal 1, sampler.stats.data_point_count
+      assert_equal 1, sampler.stats.min_call_time
+      assert_equal 1, sampler.stats.max_call_time
+      
+      lock_n_jobs(4)
+      sampler.poll
+      
+      assert_equal 2, sampler.stats.data_point_count
+      assert_equal 1, sampler.stats.min_call_time
+      assert_equal 5, sampler.stats.max_call_time
+      
+      lock_n_jobs(5)
+      sampler.poll
+      sampler.poll
+      
+      assert_equal 4, sampler.stats.data_point_count
+      assert_equal 1, sampler.stats.min_call_time
+      assert_equal 10, sampler.stats.max_call_time
+      
+      Delayed::Job.destroy_all
+      sampler.poll
+      
+      assert_equal 5, sampler.stats.data_point_count
+      assert_equal 0, sampler.stats.min_call_time
+      assert_equal 10, sampler.stats.max_call_time
+    end
+    
+  end
+end

data/test/new_relic/deployments_api_test.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'../../lib/new_relic/commands/deployments'))
+require 'rubygems'
+require 'mocha'
+
+class NewRelic::DeploymentsTest < Test::Unit::TestCase
+  
+  def setup
+    NewRelic::Commands::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
+  end
+  def teardown
+    return unless @deployment
+    puts @deployment.errors
+    puts @deployment.messages
+    puts @deployment.exit_status
+  end
+  def test_help
+    begin
+      NewRelic::Commands::Deployments.new "-h"
+      fail "should have thrown"
+    rescue NewRelic::Commands::CommandFailure => c
+      assert_match /^Usage/, c.message
+    end
+  end
+  def test_bad_command
+    assert_raise OptionParser::InvalidOption do
+      NewRelic::Commands::Deployments.new ["-foo", "bar"]
+    end
+  end
+  def test_interactive
+    mock_the_connection
+    @deployment = NewRelic::Commands::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::Commands::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
+  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::Control.instance.stubs(:http_connection).returns(mock_connection)
+  end
+  
+end

data/test/new_relic/environment_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require "test/unit"
+require "mocha"
+##require 'new_relic/local_environment'
+class EnvironmentTest < ActiveSupport::TestCase
+  
+  def teardown
+    # To remove mock server instances from ObjectSpace
+    ObjectSpace.garbage_collect
+    super
+  end
+  class MockOptions
+    def fetch (*args)
+      1000
+    end
+  end
+  MOCK_OPTIONS = MockOptions.new
+  
+  def test_environment
+    e = NewRelic::LocalEnvironment.new
+    assert_equal nil, e.environment
+    assert_match /test/i, e.dispatcher_instance_id
+  end
+  def test_no_webrick
+    Object.const_set :OPTIONS, 'foo'
+    e = NewRelic::LocalEnvironment.new
+    assert_equal nil, e.environment
+    assert_match /test/i, e.dispatcher_instance_id
+    Object.class_eval { remove_const :OPTIONS }
+  end
+
+  def test_passenger
+    class << self
+      module ::Passenger
+        const_set "AbstractServer", 0
+      end
+    end
+    e = NewRelic::LocalEnvironment.new
+    assert_equal :passenger, e.environment
+    assert_nil e.dispatcher_instance_id, "dispatcher instance id should be nil: #{e.dispatcher_instance_id}"
+      
+    NewRelic::Control.instance.instance_eval do
+      @settings['app_name'] = 'myapp'
+    end
+    
+    e = NewRelic::LocalEnvironment.new 
+    assert_equal :passenger, e.environment
+    assert_nil e.dispatcher_instance_id
+    
+    ::Passenger.class_eval { remove_const :AbstractServer }
+  end
+  def test_snapshot
+    e = NewRelic::LocalEnvironment.new
+    s = e.snapshot
+    assert_equal 0, s.size
+    e.gather_environment_info
+    s = e.snapshot
+    assert_match /1\.(8\.[67]|9\.\d)/, s.assoc('Ruby version').last, s.inspect
+    assert_equal 'test', s.assoc('Framework').last, s.inspect
+    # Make sure the processor count is determined on linux systems
+    if File.exists? '/proc/cpuinfo'
+      assert s.assoc('Processors').last.to_i > 0
+    end
+  end
+  
+  
+  def test_default_port
+    e = NewRelic::LocalEnvironment.new
+    assert_equal 3000, e.send(:default_port)
+    ARGV.push '--port=3121'
+    assert_equal '3121', e.send(:default_port)
+    ARGV.pop
+  end
+  
+end