ghazel-newrelic_rpm 3.1.0.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 < Exception; 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/collection_helper_test.rb

@@ -0,0 +1,127 @@
+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 * 100).to_s
+    assert_equal val[0...256] + "...", normalize_params(val)
+  end
+  def test_array
+    new_array = normalize_params [ 1000 ] * 2000
+    assert_equal 1024, 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["ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF..." => (("0"*256) + "...")], normalize_params({ val => '0' * 512 })
+  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
+
+  class MyEnumerable
+    include Enumerable
+
+    def each
+      yield "1"
+    end
+  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
+
+  def test_object
+    assert_equal ["foo", '#<OpenStruct>'], normalize_params(['foo', OpenStruct.new('z'=>'q')])
+  end
+
+  def test_strip_backtrace
+    begin
+      ActiveRecordFixtures.setup
+#      ActiveRecordFixtures::Order.add_delay
+      ActiveRecordFixtures::Order.find 0
+      flunk "should throw"
+    rescue => e
+      #puts e
+      #puts e.backtrace.grep(/trace/).join("\n")
+      #puts "\n\n"
+      clean_trace = strip_nr_from_backtrace(e.backtrace)
+      assert_equal 0, clean_trace.grep(/newrelic_rpm/).size, clean_trace.join("\n")
+      assert_equal 0, clean_trace.grep(/trace/).size, 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")}"
+    ensure
+      ActiveRecordFixtures.teardown
+    end
+  end if defined?(::ActiveRecord)
+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

data/test/new_relic/control/class_methods_test.rb

@@ -0,0 +1,62 @@
+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_new_instance_non_test
+    local_env = mock('local env')
+    @base.expects(:local_env).returns(local_env).at_least_once
+    local_env.expects(:framework).returns('nontest').twice
+    mock_klass = mock('klass')
+    mock_klass.expects(:new).with(local_env)
+    @base.expects(:load_framework_class).with('nontest').returns(mock_klass)
+    @base.new_instance
+  end
+  
+  def test_new_instance_test_framework
+    local_env = mock('local env')
+    local_env.expects(:framework).returns(:test)
+    @base.expects(:local_env).returns(local_env)
+    @base.expects(:load_test_framework)
+    @base.new_instance
+  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/logging_methods_test.rb

@@ -0,0 +1,157 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/control/logging_methods'
+require 'fileutils'
+
+class BaseLoggingMethods
+  # stub class to enable testing of the module
+  include NewRelic::Control::LoggingMethods
+end
+
+class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
+  def setup
+    @base = BaseLoggingMethods.new
+    super
+  end
+
+  def test_log_basic
+    mock_logger = mock('logger')
+    @base.instance_eval { @log = mock_logger }
+    assert_equal mock_logger, @base.log
+  end
+
+  def test_log_no_log
+    log = @base.log
+    assert_equal Logger, log.class
+    assert_equal Logger::INFO, log.level
+    # have to root around in the logger for the logdev
+    assert_equal STDOUT, log.instance_eval { @logdev }.dev
+  end
+
+  def test_logbang_basic
+    @base.expects(:should_log?).returns(true)
+    @base.expects(:to_stdout).with('whee')
+    @base.instance_eval { @log = nil }
+    @base.log!('whee')
+  end
+
+  def test_logbang_should_not_log
+    @base.expects(:should_log?).returns(false)
+    assert_equal nil, @base.log!('whee')
+  end
+
+  def test_logbang_with_log
+    @base.expects(:should_log?).returns(true)
+    @base.expects(:to_stdout).with('whee')
+    fake_logger = mock('log')
+    fake_logger.expects(:send).with(:info, 'whee')
+    @base.instance_eval { @log = fake_logger }
+    @base.log!('whee')
+  end
+
+  def test_should_log_no_settings
+    @base.instance_eval { @settings = nil }
+    assert !@base.should_log?
+  end
+
+  def test_should_log_agent_disabled
+    @base.instance_eval { @settings = true }
+    @base.expects(:agent_enabled?).returns(false)
+    assert !@base.should_log?
+  end
+
+  def test_should_log_agent_enabled
+    @base.instance_eval { @settings = true }
+    @base.expects(:agent_enabled?).returns(true)
+    assert @base.should_log?
+  end
+
+  def test_set_log_level_base
+    fake_logger = mock('logger')
+    # bad configuration
+    @base.expects(:fetch).with('log_level', 'info').returns('whee')
+    fake_logger.expects(:level=).with(Logger::INFO)
+    assert_equal fake_logger, @base.set_log_level!(fake_logger)
+  end
+
+  def test_set_log_level_with_each_level
+    fake_logger = mock('logger')
+    %w[debug info warn error fatal].each do |level|
+      @base.expects(:fetch).with('log_level', 'info').returns(level)
+      fake_logger.expects(:level=).with(Logger.const_get(level.upcase))
+      assert_equal fake_logger, @base.set_log_level!(fake_logger)
+    end
+  end
+
+  def test_set_log_format
+    fake_logger = Object.new
+    assert !fake_logger.respond_to?(:format_message)
+    assert_equal fake_logger, @base.set_log_format!(fake_logger)
+    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_file_name).returns('logfilename')
+    @base.expects(:set_log_format!).with(fake_logger)
+    @base.expects(:set_log_level!).with(fake_logger)
+    assert_equal fake_logger, @base.setup_log
+    assert_equal fake_logger, @base.instance_eval { @log }
+    assert_equal 'logpath/logfilename', @base.instance_eval { @log_file }
+  end
+
+  def test_to_stdout
+    STDOUT.expects(:puts).with('** [NewRelic] whee')
+    @base.to_stdout('whee')
+  end
+
+  def test_log_path_exists
+    @base.instance_eval { @log_path = 'logpath' }
+    assert_equal 'logpath', @base.log_path
+  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
+  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')
+    assert !File.directory?(path) || FileUtils.rmdir(path)
+    @base.expects(:log!).never
+    assert_equal path, @base.log_path
+    assert File.directory?(path)
+  end
+
+  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')
+    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
+    assert !File.directory?(path)
+  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
+