sundawg_newrelic_rpm 3.5.8.1

data/test/multiverse/test/suite_examples/one/b/Envfile

@@ -0,0 +1,3 @@
+gemfile <<-RUBY
+  gem "haml"
+RUBY

data/test/multiverse/test/suite_examples/one/b/b_test.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+class BTest < Test::Unit::TestCase
+  def test_timetrap_is_not_loaded
+    assert !defined?(Timetrap)
+  end
+
+  def test_haml_is_loaded
+    assert Haml
+  end
+end
+

data/test/multiverse/test/suite_examples/one/b/config/newrelic.yml

@@ -0,0 +1,24 @@
+---
+development:
+  browser_monitoring:
+    auto_instrument: true
+  error_collector:
+    capture_source: true
+    enabled: true
+  apdex_t: 0.5
+  ssl: false
+  monitor_mode: true
+  license_key: bootstrap_newrelic_admin_license_key_000
+  developer_mode: false
+  app_name: test
+  host: 127.0.0.1
+  api_host: 127.0.0.1
+  port: <%= 30_000 + ($$ % 10_000) %>
+  transaction_tracer:
+    record_sql: obfuscated
+    enabled: true
+    stack_trace_threshold: 0.5
+    transaction_threshold: 1.0
+  capture_params: false
+  log_level: debug
+  disable_serialization: false

data/test/multiverse/test/suite_examples/three/a/Envfile

@@ -0,0 +1,2 @@
+gemfile "#noop"
+execute_mode 'spawn'

data/test/multiverse/test/suite_examples/three/a/fail_test.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+class ATest < Test::Unit::TestCase
+  def test_failure
+    fail "This test is failing!!!"
+  end
+end

data/test/multiverse/test/suite_examples/three/b/Envfile

@@ -0,0 +1,2 @@
+gemfile "#noop"
+execute_mode 'fork'

data/test/multiverse/test/suite_examples/three/b/win_test.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+class ATest < Test::Unit::TestCase
+  def test_success
+    assert "This test is not failing!!!"
+  end
+end

data/test/multiverse/test/suite_examples/two/a/Envfile

@@ -0,0 +1 @@
+gemfile "#noop"

data/test/multiverse/test/suite_examples/two/a/fail_test.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+class ATest < Test::Unit::TestCase
+  def test_failure
+    fail "This test is failing!!!"
+  end
+end

data/test/new_relic/agent/agent/connect_test.rb

@@ -0,0 +1,295 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..', '..','test_helper'))
+require 'new_relic/agent/agent'
+require 'ostruct'
+
+class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
+  include NewRelic::Agent::Agent::Connect
+
+  def setup
+    @connected = nil
+    @keep_retrying = nil
+    @connect_attempts = 0
+    @connect_retry_period = 0
+    @transaction_sampler = NewRelic::Agent::TransactionSampler.new
+    @sql_sampler = NewRelic::Agent::SqlSampler.new
+    @error_collector = NewRelic::Agent::ErrorCollector.new
+    server = NewRelic::Control::Server.new('localhost', 30303)
+    @service = NewRelic::Agent::NewRelicService.new('abcdef', server)
+    @test_config = { :developer_mode => true }
+    NewRelic::Agent.config.apply_config(@test_config)
+  end
+
+  def teardown
+    NewRelic::Agent.config.remove_config(@test_config)
+  end
+
+  def control
+    fake_control = OpenStruct.new('local_env' => OpenStruct.new('snapshot' => []))
+    fake_control.instance_eval do
+      def [](key)
+        return nil
+      end
+    end
+    fake_control
+  end
+
+  def test_should_connect_if_pending
+    @connect_state = :pending
+    assert(should_connect?, "should attempt to connect if pending")
+  end
+
+  def test_should_not_connect_if_disconnected
+    @connect_state = :disconnected
+    assert(!should_connect?, "should not attempt to connect if force disconnected")
+  end
+
+  def test_should_connect_if_forced
+    @connect_state = :disconnected
+    assert(should_connect?(true), "should connect if forced")
+    @connect_state = :connected
+    assert(should_connect?(true), "should connect if forced")
+  end
+
+  def test_increment_retry_period
+    10.times do |i|
+      assert_equal((i * 60), connect_retry_period)
+      note_connect_failure
+    end
+    assert_equal(600, connect_retry_period)
+  end
+
+  def test_disconnect
+    assert disconnect
+  end
+
+  def test_log_error
+    error = StandardError.new("message")
+
+    expects_logging(:error, 
+      includes("Error establishing connection with New Relic Service"), \
+      instance_of(StandardError))
+
+    log_error(error)
+  end
+
+  def test_handle_license_error
+    error = mock(:message => "error message")
+    self.expects(:disconnect).once
+    handle_license_error(error)
+  end
+
+  def test_environment_for_connect_positive
+    fake_env = stub('local_env', :discovered_dispatcher => nil)
+    fake_env.expects(:snapshot).returns("snapshot")
+    NewRelic::Control.instance.expects(:local_env).at_least_once.returns(fake_env)
+    with_config(:send_environment_info => true) do
+      assert_equal 'snapshot', environment_for_connect
+    end
+  end
+
+  def test_environment_for_connect_negative
+    with_config(:send_environment_info => false) do
+      assert_equal [], environment_for_connect
+    end
+  end
+
+  def test_connect_settings
+    control = mocked_control
+    NewRelic::Agent.config.expects(:app_names)
+    self.expects(:environment_for_connect)
+    keys = %w(pid host app_name language agent_version environment settings)
+    value = connect_settings
+    keys.each do |k|
+      assert(value.has_key?(k.to_sym), "should include the key #{k}")
+    end
+  end
+
+  def test_configure_transaction_tracer_with_random_sampling
+    with_config(:'transaction_tracer.transaction_threshold' => 5,
+                :'transaction_tracer.random_sample' => true) do
+      sample = TransactionSampleTestHelper.make_sql_transaction
+      @transaction_sampler.store_sample(sample)
+
+      assert_equal sample, @transaction_sampler.instance_variable_get(:@random_sample)
+    end
+  end
+
+  def test_configure_transaction_tracer_positive
+    with_config(:'transaction_tracer.enabled' => true) do
+      assert @transaction_sampler.enabled?
+    end
+  end
+
+  def test_configure_transaction_tracer_negative
+    with_config(:'transaction_tracer.enabled' => false) do
+      assert @transaction_sampler.enabled?
+    end
+  end
+
+  def test_configure_transaction_tracer_server_disabled
+    config = NewRelic::Agent::Configuration::ServerSource.new('collect_traces' => false,
+                                                              'developer_mode' => false)
+    with_config(config) do
+      assert !@transaction_sampler.enabled?
+    end
+  end
+
+  def test_apdex_f
+    with_config(:apdex_t => 10) do
+      assert_equal 40, apdex_f
+    end
+  end
+
+  def test_set_sql_recording_default
+    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
+      assert_equal(:obfuscated, NewRelic::Agent::Database.record_sql_method,
+                   "should default to :obfuscated, was #{NewRelic::Agent::Database.record_sql_method}")
+    end
+  end
+
+  def test_set_sql_recording_off
+    with_config(:'transaction_tracer.record_sql' => 'off') do
+      assert_equal(:off, NewRelic::Agent::Database.record_sql_method,
+                   "should be set to :off, was #{NewRelic::Agent::Database.record_sql_method}")
+    end
+  end
+
+  def test_set_sql_recording_none
+    with_config(:'transaction_tracer.record_sql' => 'none') do
+      assert_equal(:off, NewRelic::Agent::Database.record_sql_method,
+                   "should be set to :off, was #{NewRelic::Agent::Database.record_sql_method}")
+    end
+  end
+
+  def test_set_sql_recording_raw
+    with_config(:'transaction_tracer.record_sql' => 'raw') do
+      assert_equal(:raw, NewRelic::Agent::Database.record_sql_method,
+                   "should be set to :raw, was #{NewRelic::Agent::Database.record_sql_method}")
+    end
+  end
+
+  def test_set_sql_recording_falsy
+    with_config(:'transaction_tracer.record_sql' => false) do
+      assert_equal(:off, NewRelic::Agent::Database.record_sql_method,
+                   "should be set to :off, was #{NewRelic::Agent::Database.record_sql_method}")
+    end
+  end
+
+  def test_query_server_for_configuration
+    self.expects(:connect_to_server).returns("so happy")
+    self.expects(:finish_setup).with("so happy")
+    query_server_for_configuration
+  end
+
+  def test_connect_gets_config
+    NewRelic::Agent.manual_start
+    NewRelic::Agent::Agent.instance.service = default_service(
+      :connect => {'agent_run_id' => 23, 'config' => 'a lot'})
+
+    response = NewRelic::Agent.agent.connect_to_server
+
+    assert_equal 23, response['agent_run_id']
+    assert_equal 'a lot', response['config']
+
+    NewRelic::Agent.shutdown
+  end
+
+  def test_finish_setup_saves_transaction_name_rules
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                            NewRelic::Agent::RulesEngine.new)
+    config = {
+      'transaction_name_rules' => [ { 'match_expression' => '88',
+                                      'replacement'      => '**' },
+                                    { 'match_expression' => 'xx',
+                                      'replacement'      => 'XX' } ]
+    }
+    finish_setup(config)
+
+    rules = NewRelic::Agent.instance.transaction_rules
+    assert_equal 2, rules.size
+    assert(rules.find{|r| r.match_expression == /88/ && r.replacement == '**' },
+           "rule not found among #{rules}")
+    assert(rules.find{|r| r.match_expression == /xx/ && r.replacement == 'XX' },
+           "rule not found among #{rules}")
+  ensure
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                            NewRelic::Agent::RulesEngine.new)
+  end
+
+  def test_finish_setup_saves_metric_name_rules
+    NewRelic::Agent.instance.instance_variable_set(:@metric_rules,
+                                            NewRelic::Agent::RulesEngine.new)
+    config = {
+      'metric_name_rules' => [ { 'match_expression' => '77',
+                                 'replacement'      => '&&' },
+                               { 'match_expression' => 'yy',
+                                 'replacement'      => 'YY' }]
+    }
+    finish_setup(config)
+
+    rules = NewRelic::Agent.instance.metric_rules
+    assert_equal 2, rules.size
+    assert(rules.find{|r| r.match_expression == /77/ && r.replacement == '&&' },
+           "rule not found among #{rules}")
+    assert(rules.find{|r| r.match_expression == /yy/ && r.replacement == 'YY' },
+           "rule not found among #{rules}")
+  ensure
+    NewRelic::Agent.instance.instance_variable_set(:@metric_rules,
+                                            NewRelic::Agent::RulesEngine.new)
+  end
+
+  def test_finish_setup
+    config = {
+      'agent_run_id' => 'fishsticks',
+      'collect_traces' => true,
+      'collect_errors' => true,
+      'sample_rate' => 10,
+      'agent_config' => { 'transaction_tracer.record_sql' => 'raw' }
+    }
+    self.expects(:log_connection!).with(config)
+    @transaction_sampler = stub('transaction sampler', :configure! => true,
+                                :config => {})
+    @sql_sampler = stub('sql sampler', :configure! => true)
+    with_config(:'transaction_tracer.enabled' => true) do
+      finish_setup(config)
+      assert_equal 'fishsticks', @service.agent_id
+      assert_equal 'raw', NewRelic::Agent.config[:'transaction_tracer.record_sql']
+    end
+  end
+
+
+  def test_logging_collector_messages
+    NewRelic::Agent.manual_start
+    NewRelic::Agent::Agent.instance.service = default_service(
+      :connect => {
+        'messages' => [{ 'message' => 'beep boop', 'level' => 'INFO' },
+                       { 'message' => 'ha cha cha', 'level' => 'WARN' }]
+      })
+
+    expects_logging(:info, 'beep boop')
+    expects_logging(:warn, 'ha cha cha')
+
+    NewRelic::Agent.agent.query_server_for_configuration
+    NewRelic::Agent.shutdown
+  end
+
+  def test_finish_setup_without_config
+    @service.agent_id = 'blah'
+    finish_setup(nil)
+    assert_equal 'blah', @service.agent_id
+  end
+
+  private
+
+  def mocked_control
+    fake_control = mock('control')
+    self.stubs(:control).returns(fake_control)
+    fake_control
+  end
+
+  def mocked_error_collector
+    fake_collector = mock('error collector')
+    self.stubs(:error_collector).returns(fake_collector)
+    fake_collector
+  end
+end

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

@@ -0,0 +1,205 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
+  require 'new_relic/agent/agent'
+  include NewRelic::Agent::Agent::Start
+
+  def setup
+    ENV['NEW_RELIC_APP_NAME'] = 'start_test'
+    NewRelic::Agent.reset_config
+  end
+
+  def teardown
+    ENV['NEW_RELIC_APP_NAME'] = nil
+    NewRelic::Agent.reset_config
+  end
+
+  def test_already_started_positive
+    ::Logger.any_instance.expects(:error).with("Agent Started Already!")
+    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
+    self.expects(:start_worker_thread)
+    self.expects(:install_exit_handler)
+    with_config(:sync_startup => false, :monitor_mode => true, :license_key => 'a' * 40) do
+      check_config_and_start_agent
+    end
+  end
+
+  def test_check_config_and_start_agent_sync
+    self.expects(:connect_in_foreground)
+    self.expects(:start_worker_thread)
+    self.expects(:install_exit_handler)
+    with_config(:sync_startup => true, :monitor_mode => true, :license_key => 'a' * 40) 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(:using_engine?).with('rbx').returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
+    self.expects(:using_sinatra?).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(:using_engine?).with('rbx').returns(false)
+      NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
+      self.expects(:using_sinatra?).returns(true)
+      install_exit_handler
+      NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+      NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(true)
+      install_exit_handler
+      NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').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
+
+  def test_log_unless_positive
+    # should not log
+    assert log_unless(true, :warn, "DURRR")
+  end
+
+  def test_log_unless_negative
+    # should log
+    expects_logging(:warn, "DURRR")
+    assert !log_unless(false, :warn, "DURRR")
+  end
+
+  def test_log_if_positive
+    expects_logging(:warn, "WHEE")
+    assert log_if(true, :warn, "WHEE")
+  end
+
+  def test_log_if_negative
+    assert !log_if(false, :warn, "WHEE")
+  end
+
+  private
+
+  def mocked_control
+    fake_control = mock('control')
+    self.stubs(:control).returns(fake_control)
+    fake_control
+  end
+end
+