RubyGems - newrelic_rpm - Versions diffs - 4.1.0.333 → 4.2.0.334 - Mend

newrelic_rpm 4.1.0.333 → 4.2.0.334

Files changed (788) hide show

data/test/new_relic/agent/agent/start_test.rb DELETED Viewed

@@ -1,188 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-class NewRelic::Agent::Agent::StartTest < Minitest::Test
-  require 'new_relic/agent/agent'
-  include NewRelic::Agent::Agent::Start
-  def setup
-    @harvester = stub("dummy harvester")
-    @harvest_samplers = stub("dummy sampler collection")
-  end
-  def test_already_started_positive
-    dummy_logger = mock
-    dummy_logger.expects(:error).with("Agent Started Already!")
-    NewRelic::Agent.stubs(:logger).returns(dummy_logger)
-    self.expects(:started?).returns(true)
-    assert already_started?, "should have already started"
-  end
-  def test_already_started_negative
-    self.expects(:started?).returns(false)
-    assert !already_started?
-  end
-  def test_disabled_positive
-    with_config(:agent_enabled => false) do
-      assert disabled?
-    end
-  end
-  def test_disabled_negative
-    with_config(:agent_enabled => true) do
-      assert !disabled?
-    end
-  end
-  def test_check_config_and_start_agent_disabled
-    self.expects(:monitoring?).returns(false)
-    check_config_and_start_agent
-  end
-  def test_check_config_and_start_agent_incorrect_key
-    self.expects(:monitoring?).returns(true)
-    self.expects(:has_correct_license_key?).returns(false)
-    check_config_and_start_agent
-  end
-  def test_check_config_and_start_agent_forking
-    self.expects(:monitoring?).returns(true)
-    self.expects(:has_correct_license_key?).returns(true)
-    self.expects(:using_forking_dispatcher?).returns(true)
-    check_config_and_start_agent
-  end
-  def test_check_config_and_start_agent_normal
-    @harvester.expects(:mark_started)
-    @harvest_samplers.expects(:load_samplers)
-    self.expects(:generate_environment_report)
-    self.expects(:start_worker_thread)
-    self.expects(:install_exit_handler)
-    with_config(:dispatcher => 'test', :sync_startup => false, :monitor_mode => true,
-      :license_key => 'a' * 40, :disable_samplers => false) do
-      check_config_and_start_agent
-    end
-  end
-  def test_check_config_and_start_agent_sync
-    @harvester.expects(:mark_started)
-    @harvest_samplers.expects(:load_samplers)
-    self.expects(:generate_environment_report)
-    self.expects(:connect_in_foreground)
-    self.expects(:start_worker_thread)
-    self.expects(:install_exit_handler)
-    with_config(:dispatcher => 'test', :sync_startup => true, :monitor_mode => true,
-      :license_key => 'a' * 40, :disable_samplers => false) do
-      check_config_and_start_agent
-    end
-  end
-  def test_connect_in_foreground
-    self.expects(:connect).with({:keep_retrying => false })
-    connect_in_foreground
-  end
-  def at_exit
-    yield
-  end
-  private :at_exit
-  def test_install_exit_handler_positive
-    NewRelic::LanguageSupport.expects(:jruby?).returns(false)
-    self.expects(:sinatra_classic_app?).returns(false)
-    # we are overriding at_exit above, to immediately return, so we can
-    # test the shutdown logic. It's somewhat unfortunate, but we can't
-    # kill the interpreter during a test.
-    self.expects(:shutdown)
-    with_config(:send_data_on_exit => true) do
-      install_exit_handler
-    end
-  end
-  def test_install_exit_handler_negative
-    with_config(:send_data_on_exit => false) do
-      install_exit_handler
-    end
-    # should not raise excpetion
-  end
-  def test_install_exit_handler_weird_ruby
-    with_config(:send_data_one_exit => true) do
-      NewRelic::LanguageSupport.expects(:jruby?).returns(false)
-      self.expects(:sinatra_classic_app?).returns(true)
-      install_exit_handler
-      NewRelic::LanguageSupport.expects(:jruby?).returns(true)
-      install_exit_handler
-    end
-  end
-  def test_monitoring_positive
-    with_config(:monitor_mode => true) do
-      assert monitoring?
-    end
-  end
-  def test_monitoring_negative
-    with_config(:monitor_mode => false) do
-      assert !monitoring?
-    end
-  end
-  def test_has_license_key_positive
-    with_config(:license_key => 'a' * 40) do
-      assert has_license_key?
-    end
-  end
-  def test_has_license_key_negative
-    with_config(:license_key => false) do
-      assert !has_license_key?
-    end
-  end
-  def test_has_correct_license_key_positive
-    self.expects(:has_license_key?).returns(true)
-    self.expects(:correct_license_length).returns(true)
-    assert has_correct_license_key?
-  end
-  def test_has_correct_license_key_negative
-    self.expects(:has_license_key?).returns(false)
-    assert !has_correct_license_key?
-  end
-  def test_correct_license_length_positive
-    with_config(:license_key => 'a' * 40) do
-      assert correct_license_length
-    end
-  end
-  def test_correct_license_length_negative
-    with_config(:license_key => 'a' * 30) do
-      assert !correct_license_length
-    end
-  end
-  def test_using_forking_dispatcher_positive
-    with_config(:dispatcher => :passenger) do
-      assert using_forking_dispatcher?
-    end
-  end
-  def test_using_forking_dispatcher_negative
-    with_config(:dispatcher => :frobnitz) do
-      assert !using_forking_dispatcher?
-    end
-  end
-  private
-  def mocked_control
-    fake_control = mock('control')
-    self.stubs(:control).returns(fake_control)
-    fake_control
-  end
-end

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

@@ -1,74 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-class NewRelic::Agent::Agent::StartWorkerThreadTest < Minitest::Test
-  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')
-    self.stubs(:connected?).returns(true)
-    self.expects(:create_and_run_event_loop)
-    deferred_work!('connection_options')
-  end
-  def test_deferred_work_connect_failed
-    self.expects(:catch_errors).yields
-    self.expects(:connect).with('connection_options')
-    self.stubs(:connected?).returns(false)
-    deferred_work!('connection_options')
-  end
-  def test_handle_force_restart
-    # hooray for methods with no branches
-    error = mock(:message => 'a message')
-    self.expects(:drop_buffered_data)
-    self.expects(:sleep).with(30)
-    @connected = true
-    @service = mock('service', :force_restart => nil)
-    handle_force_restart(error)
-    assert_equal(:pending, @connect_state)
-  end
-  def test_handle_force_disconnect
-    error = mock(:message => 'a message')
-    self.expects(:disconnect)
-    handle_force_disconnect(error)
-  end
-  def test_handle_other_error
-    error = StandardError.new('a message')
-    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_control
-    fake_control = mock('control')
-    self.stubs(:control).returns(fake_control)
-    fake_control
-  end
-end

data/test/new_relic/agent/agent_logger_test.rb DELETED Viewed

@@ -1,389 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-require 'new_relic/agent/agent_logger'
-require 'new_relic/agent/null_logger'
-class AgentLoggerTest < Minitest::Test
-  LEVELS = [:fatal, :error, :warn, :info, :debug]
-  def setup
-    NewRelic::Agent.config.add_config_for_testing(
-      :log_file_path => "log/",
-      :log_file_name => "testlog.log",
-      :log_level     => :info)
-  end
-  def teardown
-    NewRelic::Agent.config.reset_to_defaults
-    NewRelic::Agent::Hostname.instance_variable_set(:@hostname, nil)
-  end
-  #
-  # Tests
-  #
-  def test_initalizes_from_config
-    logger = NewRelic::Agent::AgentLogger.new
-    wrapped_logger = logger.instance_variable_get( :@log )
-    logdev = wrapped_logger.instance_variable_get( :@logdev )
-    expected_logpath = File.expand_path( NewRelic::Agent.config[:log_file_path] + NewRelic::Agent.config[:log_file_name] )
-    assert_kind_of( Logger, wrapped_logger )
-    assert_kind_of( File, logdev.dev )
-    assert_equal( expected_logpath, logdev.filename )
-  end
-  def test_initalizes_from_override
-    override_logger = Logger.new( '/dev/null' )
-    logger = NewRelic::Agent::AgentLogger.new("", override_logger)
-    assert_equal override_logger, logger.instance_variable_get(:@log)
-  end
-  def test_forwards_calls_to_logger
-    logger = create_basic_logger
-    LEVELS.each do |level|
-      logger.send(level, "Boo!")
-    end
-    assert_logged(/FATAL/,
-                  /ERROR/,
-                  /WARN/,
-                  /INFO/) # No DEBUG
-  end
-  def test_forwards_calls_to_logger_with_multiple_arguments
-    logger = create_basic_logger
-    LEVELS.each do |level|
-      logger.send(level, "What", "up?")
-    end
-    assert_logged(/FATAL/, /FATAL/,
-                  /ERROR/, /ERROR/,
-                  /WARN/,  /WARN/,
-                  /INFO/,  /INFO/) # No DEBUG
-  end
-  def test_forwards_calls_to_logger_once
-    logger = create_basic_logger
-    LEVELS.each do |level|
-      logger.send(:log_once, level, :special_key, "Special!")
-    end
-    assert_logged(/Special/)
-  end
-  def test_wont_log_if_agent_not_enabled
-    with_config(:agent_enabled => false) do
-      logger = NewRelic::Agent::AgentLogger.new
-      logger.warn('hi there')
-      assert_kind_of NewRelic::Agent::NullLogger, logger.instance_variable_get( :@log )
-    end
-  end
-  def test_consider_null_logger_a_startup_logger
-    with_config(:agent_enabled => false) do
-      logger = NewRelic::Agent::AgentLogger.new
-      assert logger.is_startup_logger?
-    end
-  end
-  def test_consider_any_other_logger_not_a_startup_logger
-    logger = NewRelic::Agent::AgentLogger.new
-    refute logger.is_startup_logger?
-  end
-  def test_does_not_touch_dev_null
-    Logger.expects(:new).with('/dev/null').never
-    with_config(:agent_enabled => false) do
-      NewRelic::Agent::AgentLogger.new
-    end
-  end
-  def test_maps_log_levels
-    assert_equal Logger::FATAL, NewRelic::Agent::AgentLogger.log_level_for(:fatal)
-    assert_equal Logger::ERROR, NewRelic::Agent::AgentLogger.log_level_for(:error)
-    assert_equal Logger::WARN,  NewRelic::Agent::AgentLogger.log_level_for(:warn)
-    assert_equal Logger::INFO,  NewRelic::Agent::AgentLogger.log_level_for(:info)
-    assert_equal Logger::DEBUG, NewRelic::Agent::AgentLogger.log_level_for(:debug)
-    assert_equal Logger::INFO, NewRelic::Agent::AgentLogger.log_level_for("")
-    assert_equal Logger::INFO, NewRelic::Agent::AgentLogger.log_level_for(:unknown)
-  end
-  def test_sets_log_level
-    with_config(:log_level => :debug) do
-      override_logger = Logger.new( $stderr )
-      override_logger.level = Logger::FATAL
-      NewRelic::Agent::AgentLogger.new("", override_logger)
-      assert_equal Logger::DEBUG, override_logger.level
-    end
-  end
-  def test_log_to_stdout_and_warns_if_failed_on_create
-    Dir.stubs(:mkdir).returns(nil)
-    with_config(:log_file_path => '/someplace/nonexistent') do
-      logger = with_squelched_stdout do
-        NewRelic::Agent::AgentLogger.new
-      end
-      wrapped_logger = logger.instance_variable_get(:@log)
-      logdev = wrapped_logger.instance_variable_get(:@logdev)
-      assert_equal $stdout, logdev.dev
-    end
-  end
-  def test_log_to_stdout_based_on_config
-    with_config(:log_file_path => 'STDOUT') do
-      logger = NewRelic::Agent::AgentLogger.new
-      wrapped_logger = logger.instance_variable_get(:@log)
-      logdev = wrapped_logger.instance_variable_get(:@logdev)
-      assert_equal $stdout, logdev.dev
-    end
-  end
-  def test_startup_purges_memory_logger
-    LEVELS.each do |level|
-      ::NewRelic::Agent::StartupLogger.instance.send(level, "boo!")
-    end
-    create_basic_logger
-    assert_logged(/FATAL/,
-                  /ERROR/,
-                  /WARN/,
-                  /INFO/) # No DEBUG
-  end
-  def test_passing_exceptions_only_logs_the_message_at_levels_higher_than_debug
-    logger = create_basic_logger
-    begin
-      raise "Something bad happened"
-    rescue => err
-      logger.error( err )
-    end
-    assert_logged(/ERROR : RuntimeError: Something bad happened/i)
-  end
-  def test_passing_exceptions_logs_the_backtrace_at_debug_level
-    with_config(:log_level => :debug) do
-      logger = create_basic_logger
-      begin
-        raise "Something bad happened"
-      rescue => err
-        logger.error( err )
-      end
-      assert_logged(/ERROR : RuntimeError: Something bad happened/i,
-                    /DEBUG : Debugging backtrace:\n.*test_passing_exceptions/i)
-    end
-  end
-  def test_default_format_contains_full_year
-    with_config(:log_level => :debug) do
-      logger = create_basic_logger
-      logger.info("The nice thing about standards is that you have so many to choose from. -- ast")
-      assert_logged(/#{Date.today.strftime("%Y-%m-%d")}/)
-    end
-  end
-  def test_format_message_allows_nil_backtrace
-    with_config(:log_level => :debug) do
-      logger = create_basic_logger
-      e = Exception.new("Look Ma, no backtrace!")
-      assert_nil(e.backtrace)
-      logger.error(e)
-      assert_logged(/ERROR : Exception: Look Ma, no backtrace!/i,
-                    /DEBUG : No backtrace available./)
-    end
-  end
-  def test_log_exception_logs_backtrace_at_same_level_as_message_by_default
-    logger = create_basic_logger
-    e = Exception.new("howdy")
-    e.set_backtrace(["wiggle", "wobble", "topple"])
-    logger.log_exception(:info, e)
-    assert_logged(/INFO : Exception: howdy/i,
-                  /INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/)
-  end
-  def test_log_exception_logs_backtrace_at_explicitly_specified_level
-    logger = create_basic_logger
-    e = Exception.new("howdy")
-    e.set_backtrace(["wiggle", "wobble", "topple"])
-    logger.log_exception(:warn, e, :info)
-    assert_logged(/WARN : Exception: howdy/i,
-                  /INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/)
-  end
-  def recursion_is_an_antipattern
-    recursion_is_an_antipattern
-  end
-  def test_log_exception_gets_backtrace_for_system_stack_error
-    # This facility compensates for poor SystemStackError traces on MRI.
-    # JRuby raises errors with good backtraces, so skip this test.
-    return if NewRelic::LanguageSupport.jruby?
-    logger = create_basic_logger
-    begin
-      recursion_is_an_antipattern
-    rescue SystemStackError => e
-      logger.log_exception(:error, e)
-    end
-    assert_logged(/ERROR : /,
-                  /ERROR : Debugging backtrace:\n.*#{__method__}/)
-  end
-  def test_logs_to_stdout_if_fails_on_file
-    Logger::LogDevice.any_instance.stubs(:open).raises(Errno::EACCES)
-    logger = with_squelched_stdout do
-      NewRelic::Agent::AgentLogger.new
-    end
-    wrapped_logger = logger.instance_variable_get(:@log)
-    logdev = wrapped_logger.instance_variable_get(:@logdev)
-    assert_equal $stdout, logdev.dev
-  end
-  def test_null_logger_works_with_impolite_gems_that_add_stuff_to_kernel
-    Kernel.module_eval do
-      def debug; end
-    end
-    logger = NewRelic::Agent::AgentLogger.new
-    with_config(:agent_enabled => false) do
-      logger.debug('hi!')
-    end
-  ensure
-    Kernel.module_eval do
-      remove_method :debug
-    end
-  end
-  def test_should_cache_hostname
-    NewRelic::Agent::Hostname.instance_variable_set(:@hostname, nil)
-    Socket.expects(:gethostname).once.returns('cachey-mccaherson')
-    logger = create_basic_logger
-    logger.warn("one")
-    logger.warn("two")
-    logger.warn("three")
-    host_regex = /cachey-mccaherson/
-    assert_logged(host_regex, host_regex, host_regex)
-  end
-  def test_should_not_evaluate_blocks_unless_log_level_is_high_enough
-    with_config(:log_level => 'warn') do
-      logger = create_basic_logger
-      block_was_evalutated = false
-      logger.info do
-        block_was_evalutated = true
-      end
-      refute block_was_evalutated
-    end
-  end
-  def test_should_allow_blocks_that_return_a_single_string
-    logger = create_basic_logger
-    logger.warn { "Surely you jest!" }
-    assert_logged(/WARN : Surely you jest!/)
-  end
-  def test_should_allow_blocks_that_return_an_array
-    logger = create_basic_logger
-    logger.warn do
-      ["You must be joking!", "You can't be serious!"]
-    end
-    assert_logged(
-      /WARN : You must be joking!/,
-      /WARN : You can't be serious!/
-    )
-  end
-  def test_can_overwrite_log_formatter
-    log_message   = 'How are you?'
-    log_formatter = Proc.new { |s, t, p, m| m.reverse }
-    logger = create_basic_logger
-    logger.log_formatter = log_formatter
-    logger.warn log_message
-    assert_logged log_message.reverse
-  end
-  def test_clear_already_logged
-    logger = create_basic_logger
-    logger.log_once(:warn, :positive, "thoughts")
-    logger.log_once(:warn, :positive, "thoughts")
-    assert_logged "thoughts"
-    logger.clear_already_logged
-    logger.log_once(:warn, :positive, "thoughts")
-    assert_logged "thoughts", "thoughts"
-  end
-  #
-  # Helpers
-  #
-  def logged_lines
-    @logdev.array
-  end
-  def create_basic_logger
-    @logdev = ArrayLogDevice.new
-    override_logger = Logger.new(@logdev)
-    NewRelic::Agent::AgentLogger.new("", override_logger)
-  end
-  def with_squelched_stdout
-    orig = $stdout.dup
-    $stdout.reopen( '/dev/null' )
-    yield
-  ensure
-    $stdout.reopen( orig )
-  end
-  def assert_logged(*args)
-    assert_equal(args.length, logged_lines.length, "Unexpected log length #{logged_lines}")
-    logged_lines.each_with_index do |line, index|
-      assert_match(args[index], line, "Missing match for #{args[index]}")
-    end
-  end
-end