wd_newrelic_rpm 3.3.4.1

data/test/new_relic/agent/worker_loop_test.rb

@@ -0,0 +1,66 @@
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
+  def setup
+    @log = ""
+    @logger = Logger.new(StringIO.new(@log))
+    @worker_loop = NewRelic::Agent::WorkerLoop.new
+    @worker_loop.stubs(:log).returns(@logger)
+    @test_start_time = Time.now
+  end
+
+  def test_add_task
+    @x = false
+    @worker_loop.run(0) do
+      @worker_loop.stop
+      @x = true
+    end
+    assert @x
+  end
+
+  def test_density
+    # This shows how the tasks stay aligned with the period and don't drift.
+    count = 0
+    start = Time.now
+    @worker_loop.run(0.01) do
+      count +=1
+      if count == 3
+        @worker_loop.stop
+        next
+      end
+    end
+    elapsed = Time.now - start
+    assert_in_delta 0.03, elapsed, 0.02
+  end
+  def test_task_error__standard
+    @logger.expects(:debug)
+    @logger.expects(:error)
+    # This loop task will run twice
+    done = false
+    @worker_loop.run(0) do
+      @worker_loop.stop
+      done = true
+      raise "Standard Error Test"
+    end
+    assert done
+  end
+  class BadBoy < StandardError; end
+
+  def test_task_error__exception
+    @logger.expects(:error).once
+    @logger.expects(:debug).once
+    @worker_loop.run(0) do
+      @worker_loop.stop
+      raise BadBoy, "oops"
+    end
+  end
+  def test_task_error__server
+    @logger.expects(:error).never
+    @logger.expects(:debug).once
+    @worker_loop.run(0) do
+      @worker_loop.stop
+      raise NewRelic::Agent::ServerError, "Runtime Error Test"
+    end
+  end
+end

data/test/new_relic/agent_test.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+module NewRelic
+  class MainAgentTest < Test::Unit::TestCase
+    
+    # mostly this module just passes through to the active agent
+    # through the agent method or the control instance through
+    # NewRelic::Control.instance . But it's nice to make sure.
+
+    def teardown
+      super
+      Thread.current[:newrelic_untraced] = nil
+    end
+    
+    def test_shutdown
+      mock_agent = mocked_agent
+      mock_agent.expects(:shutdown).with({})
+      NewRelic::Agent.shutdown
+    end
+
+    def test_after_fork
+      mock_agent = mocked_agent
+      mock_agent.expects(:after_fork).with({})
+      NewRelic::Agent.after_fork
+    end
+    
+    def test_reset_stats
+      mock_agent = mocked_agent
+      mock_agent.expects(:reset_stats)
+      NewRelic::Agent.reset_stats
+    end
+
+    def test_manual_start_default
+      mock_control = mocked_control
+      mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => true})
+      NewRelic::Agent.manual_start
+    end
+    
+    def test_manual_start_with_opts
+      mock_control = mocked_control
+      mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => false})
+      NewRelic::Agent.manual_start(:sync_startup => false)
+    end
+
+    def test_logger
+      control = mocked_control
+      control.expects(:log)
+      NewRelic::Agent.logger
+    end
+
+    def test_browser_timing_header
+      agent = mocked_agent
+      agent.expects(:browser_timing_header)
+      NewRelic::Agent.browser_timing_header
+    end
+
+    def test_browser_timing_footer
+      agent = mocked_agent
+      agent.expects(:browser_timing_footer)
+      NewRelic::Agent.browser_timing_footer
+    end
+
+    def test_get_stats
+      agent = mocked_agent
+      mock_stats_engine = mock('stats_engine')
+      agent.expects(:stats_engine).returns(mock_stats_engine)
+      mock_stats_engine.expects(:get_stats).with('Custom/test/metric', false)
+      NewRelic::Agent.get_stats('Custom/test/metric')
+    end
+    
+    # note that this is the same as get_stats above, they're just aliases
+    def test_get_stats_no_scope
+      agent = mocked_agent
+      mock_stats_engine = mock('stats_engine')
+      agent.expects(:stats_engine).returns(mock_stats_engine)
+      mock_stats_engine.expects(:get_stats).with('Custom/test/metric', false)
+      NewRelic::Agent.get_stats_no_scope('Custom/test/metric')
+    end
+
+    def test_agent_not_started
+      old_agent = NewRelic::Agent.agent
+      NewRelic::Agent.instance_eval { @agent = nil }
+      assert_raise(RuntimeError) do
+        NewRelic::Agent.agent
+      end
+      NewRelic::Agent.instance_eval { @agent = old_agent }
+    end
+
+    def test_agent_when_started
+      old_agent = NewRelic::Agent.agent
+      NewRelic::Agent.instance_eval { @agent = 'not nil' }
+      assert_equal('not nil', NewRelic::Agent.agent, "should return the value from @agent")
+      NewRelic::Agent.instance_eval { @agent = old_agent }
+    end
+
+    def test_abort_transaction_bang
+      NewRelic::Agent::Instrumentation::MetricFrame.expects(:abort_transaction!)
+      NewRelic::Agent.abort_transaction!
+    end
+
+    def test_is_transaction_traced_true
+      Thread.current[:record_tt] = true
+      assert_equal(true, NewRelic::Agent.is_transaction_traced?, 'should be true since the thread local is set')
+    end
+
+    def test_is_transaction_traced_blank
+      Thread.current[:record_tt] = nil
+      assert_equal(true, NewRelic::Agent.is_transaction_traced?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_transaction_traced_false
+      Thread.current[:record_tt] = false
+      assert_equal(false, NewRelic::Agent.is_transaction_traced?, 'should be false since the thread local is false')
+    end
+    
+    def test_is_sql_recorded_true
+      Thread.current[:record_sql] = true
+      assert_equal(true, NewRelic::Agent.is_sql_recorded?, 'should be true since the thread local is set')
+    end
+
+    def test_is_sql_recorded_blank
+      Thread.current[:record_sql] = nil
+      assert_equal(true, NewRelic::Agent.is_sql_recorded?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_sql_recorded_false
+      Thread.current[:record_sql] = false
+      assert_equal(false, NewRelic::Agent.is_sql_recorded?, 'should be false since the thread local is false')
+    end
+    
+    def test_is_execution_traced_true
+      Thread.current[:newrelic_untraced] = [true, true]
+      assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is set')
+    end
+
+    def test_is_execution_traced_blank
+      Thread.current[:newrelic_untraced] = nil
+      assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_execution_traced_empty
+      Thread.current[:newrelic_untraced] = []
+      assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is an empty array')
+    end
+
+    def test_is_execution_traced_false
+      Thread.current[:newrelic_untraced] = [true, false]
+      assert_equal(false, NewRelic::Agent.is_execution_traced?, 'should be false since the thread local stack has the last element false')
+    end
+    
+    def test_instance
+      assert_equal(NewRelic::Agent.agent, NewRelic::Agent.instance, "should return the same agent for both identical methods")
+    end
+
+    def test_load_data_should_disable_serialization_if_an_error_is_encountered
+      NewRelic::Control.instance['disable_serialization'] = false
+      NewRelic::DataSerialization.stubs(:should_send_data?).returns(false)
+      NewRelic::Agent.stubs(:save_data).raises(Errno::EACCES)
+      begin
+        NewRelic::Agent.instance.send(:save_or_transmit_data)
+      rescue Errno::EACCES; end
+      # should be true
+      assert(NewRelic::Control.instance['disable_serialization'])
+      NewRelic::Control.instance['disable_serialization'] = false
+    end
+
+    def test_load_data_should_not_write_files_when_serialization_disabled
+      NewRelic::Control.instance['disable_serialization'] = true
+      NewRelic::DataSerialization.expects(:read_and_write_to_file).never
+      NewRelic::Agent.load_data
+      NewRelic::Control.instance['disable_serialization'] = false
+    end
+
+    private
+
+    def mocked_agent
+      agent = mock('agent')
+      NewRelic::Agent.stubs(:agent).returns(agent)
+      agent
+    end
+
+    def mocked_control
+      control = mock('control')
+      NewRelic::Control.stubs(:instance).returns(control)
+      control
+    end
+  end
+end

data/test/new_relic/collection_helper_test.rb

@@ -0,0 +1,149 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'ostruct'
+require 'active_record_fixtures' if defined?(::ActiveRecord)
+
+require 'new_relic/collection_helper'
+class NewRelic::CollectionHelperTest < Test::Unit::TestCase
+
+  def setup
+    NewRelic::Agent.manual_start
+    super
+  end
+  def teardown
+    super
+  end
+
+  include NewRelic::CollectionHelper
+  def test_string
+    val = (('A'..'Z').to_a.join * 1024).to_s
+    assert_equal val[0...16384] + "...", normalize_params(val)
+  end
+  def test_array
+    new_array = normalize_params [ 1000 ] * 2000
+    assert_equal 128, new_array.size
+    assert_equal '1000', new_array[0]
+  end
+  def test_boolean
+    np = normalize_params(NewRelic::Control.instance.settings)
+    assert_equal false, np['monitor_mode']
+  end
+  def test_string__singleton
+    val = "This String"
+    def val.hello; end
+    assert_equal "This String", normalize_params(val)
+    assert val.respond_to?(:hello)
+    assert !normalize_params(val).respond_to?(:hello)
+  end
+  class MyString < String; end
+  def test_kind_of_string
+    s = MyString.new "This is a string"
+    assert_equal "This is a string", s.to_s
+    assert_equal MyString, s.class
+    assert_equal String, s.to_s.class
+    params = normalize_params(:val => [s])
+    assert_equal String, params[:val][0].class
+    assert_equal String, flatten(s).class
+    assert_equal String, truncate(s, 2).class
+  end
+  def test_number
+    np = normalize_params({ 'one' => 1.0, 'two' => '2'})
+  end
+  def test_nil
+    np = normalize_params({ nil => 1.0, 'two' => nil})
+    assert_equal "1.0", np['']
+    assert_equal nil, np['two']
+  end
+  def test_hash
+    val = ('A'..'Z').to_a.join * 100
+    assert_equal Hash[(val[0..63] + "...") => (("0"*16384) + "...")], normalize_params({ val => '0' * (16384*2) })
+  end
+  class MyHash < Hash
+
+  end
+  # Test to ensure that hash subclasses are properly converted
+  def test_hash_subclass
+    h = MyHash.new
+    h[:mine] = 'mine'
+    custom_params = { :one => {:hash => { :a => :b}, :myhash => h }}
+    nh = normalize_params(custom_params)
+    myhash = custom_params[:one][:myhash]
+    assert_equal MyHash, myhash.class
+    myhash = nh[:one][:myhash]
+    assert_equal Hash, myhash.class
+  end
+
+
+
+  def test_enumerable
+    e = MyEnumerable.new
+    custom_params = { :one => {:hash => { :a => :b}, :myenum => e }}
+    nh = normalize_params(custom_params)
+    myenum = nh[:one][:myenum]
+    assert_match /MyEnumerable/, myenum
+  end
+
+  def test_stringio
+    # Verify StringIO works like this normally:
+    s = StringIO.new "start" + ("foo bar bat " * 1000)
+    val = nil
+    s.each { | entry | val = entry; break }
+    assert_match /^startfoo bar/, val
+
+    # make sure stringios aren't affected by calling normalize_params:
+    s = StringIO.new "start" + ("foo bar bat " * 1000)
+    v = normalize_params({ :foo => s.string })
+    s.each { | entry | val = entry; break }
+    assert_match /^startfoo bar/, val
+  end
+  class MyEnumerable
+    include Enumerable
+    
+    def each
+      yield "1"
+    end
+  end
+  
+  def test_object
+    assert_equal ["foo", '#<OpenStruct>'], normalize_params(['foo', OpenStruct.new('z'=>'q')])
+  end
+
+  def test_strip_backtrace
+    clean_trace = strip_nr_from_backtrace(mock_backtrace)
+    assert_equal(0, clean_trace.grep(/newrelic_rpm/).size,
+                 "should remove all instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
+    assert_equal(0, clean_trace.grep(/trace/).size, 
+                     "should remove trace method tags from method names but got: #{clean_trace.join("\n")}")
+    assert((clean_trace.grep(/find/).size >= 3),
+               "should see at least three frames with 'find' in them: \n#{clean_trace.join("\n")}")
+  end
+
+  def test_disabled_strip_backtrace
+    NewRelic::Control.instance['disable_backtrace_cleanup'] = true
+    clean_trace = strip_nr_from_backtrace(mock_backtrace)
+    assert_equal(1, clean_trace.grep(/new_relic/).size,
+            "should not remove instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
+    assert_equal(1, clean_trace.grep(/_trace/).size, 
+                   "should not remove trace method tags from method names but got: #{clean_trace.join("\n")}")
+    #       assert (clean_trace.grep(/find/).size >= 3), "should see at least three frames with 'find' in them (#{e}): \n#{clean_trace.join("\n")}"
+    NewRelic::Control.instance['disable_backtrace_cleanup'] = false
+  end
+  
+  private 
+  def mock_backtrace
+    [
+   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1620:in `find_one_without_trace'}, 
+   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1620:in `find_one'}, 
+   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1603:in `find_from_ids'}, 
+   %q{./test/new_relic/collection_helper_test.rb:112:in `test_strip_stackdump'}, 
+   %q{/home/app/gems/mocha-0.9.8/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb:19:in `__send__'}, 
+   %q{/home/app/gems/mocha-0.9.8/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb:19:in `run'}, 
+   %q{/home/app/test/unit/testsuite.rb:34:in `run'}, 
+   %q{/home/app/test/unit/testsuite.rb:33:in `each'}, 
+   %q{/home/app/test/unit/testsuite.rb:33:in `run'}, 
+   %q{/home/app/test/unit/testsuite.rb:34:in `run'}, 
+   %q{/home/app/test/unit/testsuite.rb:33:in `each'}, 
+   %q{/home/app/test/unit/testsuite.rb:33:in `run'}, 
+   %q{/home/app/test/unit/ui/testrunnermediator.rb:46:in `run_suite'}
+   ]
+  end
+end

data/test/new_relic/command/deployments_test.rb

@@ -0,0 +1,68 @@
+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
+  end
+  def teardown
+    super
+    return unless @deployment
+    puts @deployment.errors
+    puts @deployment.messages
+    puts @deployment.exit_status
+  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
+  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