ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

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

@@ -4,7 +4,7 @@ require 'ostruct'
 
 class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   include NewRelic::Agent::Agent::Connect
-  
+
   def setup
     @connected = nil
     @keep_retrying = nil
@@ -14,6 +14,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     @sql_sampler = NewRelic::Agent::SqlSampler.new
     server = NewRelic::Control::Server.new('localhost', 30303)
     @service = NewRelic::Agent::NewRelicService.new('abcdef', server)
+    log.stubs(:warn => true, :info => true, :debug => true)
   end
 
   def control
@@ -120,55 +121,44 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_log_seed_token
-    fake_control = mocked_control
-    fake_control.expects(:validate_seed).times(2).returns("many seeds")
-    fake_control.expects(:validate_token).once.returns("a token, man")
-    log.expects(:debug).with("Connecting with validation seed/token: many seeds/a token, man").once
-    log_seed_token
+    with_config(:validate_seed => 'many seeds', :validate_token => 'a token, man') do
+      log.expects(:debug).with("Connecting with validation seed/token: many seeds/a token, man").once
+      log_seed_token
+    end
   end
 
   def test_no_seed_token
-    fake_control = mocked_control
-    fake_control.expects(:validate_seed).once.returns(nil)
-    log.expects(:debug).never
-    log_seed_token
+    with_config(:validate_seed => false) do
+      log.expects(:debug).never
+      log_seed_token
+    end
   end
 
-  def mocks_for_positive_environment_for_connect(value_for_control)
-    control = mocked_control
-    control.expects(:'[]').with('send_environment_info').once.returns(value_for_control)
+  def test_environment_for_connect_positive
     fake_env = mock('local_env')
     fake_env.expects(:snapshot).once.returns("snapshot")
-    control.expects(:local_env).once.returns(fake_env)
-  end
-
-  def test_environment_for_connect_nil
-    mocks_for_positive_environment_for_connect(nil)
-    assert_equal 'snapshot', environment_for_connect
-  end
-
-  def test_environment_for_connect_positive
-    mocks_for_positive_environment_for_connect(true)
-    assert_equal 'snapshot', environment_for_connect
+    NewRelic::Control.instance.expects(:local_env).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
-    control = mocked_control
-    control.expects(:'[]').with('send_environment_info').once.returns(false)
-    assert_equal [], environment_for_connect
+    with_config(:send_environment_info => false) do
+      assert_equal [], environment_for_connect
+    end
   end
 
   def test_validate_settings
-    control = mocked_control
-    control.expects(:validate_seed).once
-    control.expects(:validate_token).once
-    assert_equal({:seed => nil, :token => nil}, validate_settings)
+    with_config(:validate_seed => 'seed', :validate_token => 'token') do
+      assert_equal 'seed', NewRelic::Agent.instance.validate_settings[:seed]
+      assert_equal 'token', NewRelic::Agent.instance.validate_settings[:token]
+    end
   end
 
   def test_connect_settings
     control = mocked_control
-    control.expects(:app_names)
-    control.expects(:settings)
+    NewRelic::Agent.config.expects(:app_names)
     self.expects(:validate_settings)
     self.expects(:environment_for_connect)
     keys = %w(pid host app_name language agent_version environment settings validate)
@@ -179,162 +169,111 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_configure_error_collector_base
-    fake_collector = mocked_error_collector
-    fake_collector.expects(:config_enabled).returns(false)
-    fake_collector.expects(:enabled=).with(false)
-    log.expects(:debug).with("Errors will not be sent to the New Relic service.")
-    configure_error_collector!(false)
+    error_collector = NewRelic::Agent::ErrorCollector.new
+    NewRelic::Control.instance.log.stubs(:debug)
+    NewRelic::Control.instance.log.expects(:debug) \
+      .with("Errors will not be sent to the New Relic service.").at_least_once
+    with_config(:'error_collector.enabled' => false) do
+      # noop
+    end
   end
 
   def test_configure_error_collector_enabled
-    fake_collector = mocked_error_collector
-    fake_collector.expects(:config_enabled).returns(true)
-    fake_collector.expects(:enabled=).with(true)
-    log.expects(:debug).with("Errors will be sent to the New Relic service.")
-    configure_error_collector!(true)
+    with_config(:'error_collector.enabled' => false) do
+      error_collector = NewRelic::Agent::ErrorCollector.new
+      NewRelic::Control.instance.log.stubs(:debug)
+      NewRelic::Control.instance.log.expects(:debug) \
+        .with("Errors will be sent to the New Relic service.").at_least_once
+      with_config(:'error_collector.enabled' => true) do
+        # noop
+      end
+    end
   end
 
   def test_configure_error_collector_server_disabled
-    fake_collector = mocked_error_collector
-    fake_collector.expects(:config_enabled).returns(true)
-    fake_collector.expects(:enabled=).with(false)
-    log.expects(:debug).with("Errors will not be sent to the New Relic service.")
-    configure_error_collector!(false)
-  end
-
-  def test_enable_random_samples
-    sampling_rate = 10
-    ts = @transaction_sampler = mock('ts')
-    ts.expects(:random_sampling=).with(true)
-    ts.expects(:sampling_rate=).with(sampling_rate)
-    ts.expects(:sampling_rate).returns(sampling_rate)
-    log.expects(:info).with("Transaction sampling enabled, rate = 10")
-    enable_random_samples!(sampling_rate)
-  end
-
-  def test_enable_random_samples_with_no_sampling_rate
-    # testing that we set a sane default for sampling rate
-    sampling_rate = 0
-    ts = @transaction_sampler = mock('ts')
-    ts.expects(:random_sampling=).with(true)
-    ts.expects(:sampling_rate=).with(10)
-    ts.expects(:sampling_rate).returns(10)
-    log.expects(:info).with("Transaction sampling enabled, rate = 10")
-    enable_random_samples!(sampling_rate)
-  end
-
-  def test_config_transaction_tracer
-    NewRelic::Control.instance.settings['transaction_tracer'] = {
-      'enabled' => true,
-      'random_sample' => false,
-      'explain_threshold' => 0.75,
-      'explain_enabled' => true
-    }
-
-    config_transaction_tracer
-
-    assert @transaction_sampler.enabled?
-    assert_equal 0.75, @transaction_sampler.explain_threshold
-    assert @transaction_sampler.explain_enabled
-#     assert_equal 1.5, @transaction_sampler.transaction_threshold
+    error_collector = NewRelic::Agent::ErrorCollector.new
+    NewRelic::Control.instance.log.stubs(:debug)
+    NewRelic::Control.instance.log.expects(:debug) \
+      .with("Errors will not be sent to the New Relic service.").at_least_once
+    config = NewRelic::Agent::Configuration::ServerSource.new('collect_errors' => false)
+    with_config(config) do
+      # noop
+    end
   end
 
   def test_configure_transaction_tracer_with_random_sampling
-    @config_should_send_samples = true
-    @should_send_random_samples = true
-    @slowest_transaction_threshold = 5
-    log.stubs(:debug)
-    self.expects(:enable_random_samples!).with(10)
-    configure_transaction_tracer!(true, 10)
-    assert @should_send_samples
-    assert_equal 5, @transaction_sampler.slow_capture_threshold
+    with_config(:'transaction_tracer.transaction_threshold' => 5,
+                :'transaction_tracer.random_sample' => true) do
+      log.stubs(:debug)
+      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
-    @config_should_send_samples = true
-    @slowest_transaction_threshold = 5
-    log.stubs(:debug)
-    configure_transaction_tracer!(true, 10)
-    assert @should_send_samples
-    assert_equal 5, @transaction_sampler.slow_capture_threshold
+    with_config(:'transaction_tracer.enabled' => true) do
+      assert @transaction_sampler.enabled?
+    end
   end
 
   def test_configure_transaction_tracer_negative
-    @config_should_send_samples = false
-    log.expects(:debug).with('Transaction traces will not be sent to the New Relic service.')
-    configure_transaction_tracer!(true, 10)
-    assert !@should_send_samples
+    with_config(:'transaction_tracer.enabled' => false) do
+      assert @transaction_sampler.enabled?
+    end
   end
 
   def test_configure_transaction_tracer_server_disabled
-    @config_should_send_samples = true
+    @transaction_sampler.stubs(:log).returns(log)
+    log.stubs(:debug)
     log.expects(:debug).with('Transaction traces will not be sent to the New Relic service.')
-    configure_transaction_tracer!(false, 10)
-    assert !@should_send_samples
+    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
-    NewRelic::Control.instance.expects(:apdex_t).returns(10)
-    assert_equal 40, apdex_f
-  end
-
-  def test_apdex_f_threshold_positive
-    NewRelic::Control.instance.settings['transaction_tracer'] = { 'transaction_threshold' => 'apdex_f' }
-    assert apdex_f_threshold?
-  end
-
-  def test_apdex_f_threshold_negative
-    NewRelic::Control.instance.settings['transaction_tracer'] = { 'transaction_threshold' => 'WHEE' }
-    assert !apdex_f_threshold?
+    with_config(:apdex_t => 10) do
+      assert_equal 40, apdex_f
+    end
   end
 
   def test_set_sql_recording_default
-    NewRelic::Control.instance.settings['transaction_tracer'] = { }
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :obfuscated, @record_sql, " should default to :obfuscated, was #{@record_sql}"
+    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
-    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => 'off'}
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+    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
-    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => 'none'}    
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+    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
-    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => 'raw'}        
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :raw, @record_sql, "should be set to :raw, was #{@record_sql}"
+    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
-    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => false}            
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
-  end
-
-  def test_log_sql_transmission_warning_negative
-    log = mocked_log
-    @record_sql = :obfuscated
-    log.expects(:warn).never
-    log_sql_transmission_warning?
-  end
-
-  def test_log_sql_transmission_warning_positive
-    log = mocked_log
-    @record_sql = :raw
-    log.expects(:warn).with('Agent is configured to send raw SQL to the service')
-    log_sql_transmission_warning?
+    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
@@ -344,9 +283,9 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_connect_to_server_gets_config_from_collector
+    NewRelic::Agent.manual_start
     service = NewRelic::FakeService.new
     NewRelic::Agent::Agent.instance.service = service
-    NewRelic::Agent.manual_start
     service.mock['connect'] = {'agent_run_id' => 23, 'config' => 'a lot'}
 
     response = NewRelic::Agent.agent.connect_to_server
@@ -360,23 +299,38 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   def test_finish_setup
     config = {
       'agent_run_id' => 'fishsticks',
-      'data_report_period' => 'pasta sauce',
-      'url_rules' => 'tamales',
       'collect_traces' => true,
       'collect_errors' => true,
-      'sample_rate' => 10
+      'sample_rate' => 10,
+      'agent_config' => { 'transaction_tracer.record_sql' => 'raw' }
     }
-    NewRelic::Control.instance.settings['transaction_tracer'] = {'enabled' => true}
     self.expects(:log_connection!).with(config)
-    self.expects(:configure_transaction_tracer!).with(true, 10)
-    self.expects(:configure_error_collector!).with(true)
     @transaction_sampler = stub('transaction sampler', :configure! => true,
                                 :config => {})
-    @sql_sampler = stub('sql sampler', :configure! => true)    
-    finish_setup(config)
-    assert_equal 'fishsticks', @service.agent_id
-    assert_equal 'pasta sauce', @report_period
-    assert_equal 'tamales', @url_rules
+    @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
+    service = NewRelic::FakeService.new
+    NewRelic::Agent::Agent.instance.service = service
+    service.mock['connect'] = {
+      'agent_run_id' => 23, 'config' => 'a lot',
+      'messages' => [{ 'message' => 'beep boop', 'level' => 'INFO' },
+                     { 'message' => 'ha cha cha', 'level' => 'WARN' }]
+    }
+
+    NewRelic::Control.instance.log.stubs(:info)
+    NewRelic::Control.instance.log.expects(:info).with('beep boop')
+    NewRelic::Control.instance.log.expects(:warn).with('ha cha cha')
+
+    NewRelic::Agent.agent.query_server_for_configuration
+    NewRelic::Agent.shutdown
   end
 
   def test_finish_setup_without_config
@@ -385,6 +339,22 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     assert_equal 'blah', @service.agent_id
   end
 
+  # no idea why this test leaks in Rails 2.0
+  # will be moved to a multiverse test eventually anyway
+  if !Rails::VERSION::STRING =~ /2\.0.*/
+    def test_set_apdex_t_from_server
+      service = NewRelic::FakeService.new
+      NewRelic::Agent::Agent.instance.service = service
+      service.mock['connect'] = { 'apdex_t' => 0.5 }
+      with_config(:sync_startup => true, :monitor_mode => true,
+                  :license_key => 'a' * 40) do
+        NewRelic::Agent.manual_start
+        assert_equal 0.5, NewRelic::Agent.config[:apdex_t]
+        NewRelic::Agent.shutdown
+      end
+    end
+  end
+
   private
 
   def mocked_control

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

@@ -3,6 +3,16 @@ 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
     control = mocked_control
     control.expects(:log!).with("Agent Started Already!", :error)
@@ -16,39 +26,64 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_disabled_positive
-    control = mocked_control
-    control.expects(:agent_enabled?).returns(false)
-    assert disabled?
+    with_config(:agent_enabled => false) do
+      assert disabled?
+    end
   end
 
   def test_disabled_negative
-    control = mocked_control
-    control.expects(:agent_enabled?).returns(true)
-    assert !disabled?
+    with_config(:agent_enabled => true) do
+      assert !disabled?
+    end
   end
 
   def test_log_dispatcher_positive
-    control = mocked_control
     log = mocked_log
-    control.expects(:dispatcher).returns('Y U NO SERVE WEBPAGE')
-    log.expects(:info).with("Dispatcher: Y U NO SERVE WEBPAGE")
-    log_dispatcher
+    with_config(:dispatcher => 'Y U NO SERVE WEBPAGE') do
+      log.expects(:info).with("Dispatcher: Y U NO SERVE WEBPAGE")
+      log_dispatcher
+    end
   end
 
   def test_log_dispatcher_negative
-    control = mocked_control
     log = mocked_log
-    control.expects(:dispatcher).returns('')
-    log.expects(:info).with("No dispatcher detected.")
-    log_dispatcher
+    with_config(:dispatcher => '') do
+      log.expects(:info).with("No dispatcher detected.")
+      log_dispatcher
+    end
   end
 
-  def test_log_app_names
-    control = mocked_control
-    log = mocked_log
-    control.expects(:app_names).returns(%w(zam zam zabam))
-    log.expects(:info).with("Application: zam, zam, zabam")
-    log_app_names
+  def test_log_app_names_string
+    with_config(:app_name => 'zam;zam;zabam') do
+      log = mocked_log
+      log.expects(:info).with("Application: zam, zam, zabam")
+      log_app_names
+    end
+  end
+
+  def test_log_app_names_array
+    with_config(:app_name => ['zam', 'zam', 'zabam']) do
+      log = mocked_log
+      log.expects(:info).with("Application: zam, zam, zabam")
+      log_app_names
+    end
+  end
+
+  def test_log_app_names_with_env_var
+    # bad app name after env - used to cover the yaml config
+    with_config({:app_name => false}, 1) do
+      log = mocked_log
+      log.expects(:info).with("Application: start_test") # set in setup
+      log_app_names
+    end
+  end
+
+  def test_log_app_names_with_unknown
+    with_config(:app_name => false) do
+      log = mocked_log
+      log.expects(:error).with('Unable to determine application name. Please set the application name in your newrelic.yml or in a NEW_RELIC_APP_NAME environment variable.')
+      log_app_names
+    end
   end
 
   def test_check_config_and_start_agent_disabled
@@ -70,26 +105,20 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_check_config_and_start_agent_normal
-    self.expects(:monitoring?).returns(true)
-    self.expects(:has_correct_license_key?).returns(true)
-    self.expects(:using_forking_dispatcher?).returns(false)
-    control = mocked_control
-    control.expects(:sync_startup).returns(false)
     self.expects(:start_worker_thread)
     self.expects(:install_exit_handler)
-    check_config_and_start_agent
+    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(:monitoring?).returns(true)
-    self.expects(:has_correct_license_key?).returns(true)
-    self.expects(:using_forking_dispatcher?).returns(false)
-    control = mocked_control
-    control.expects(:sync_startup).returns(true)
     self.expects(:connect_in_foreground)
     self.expects(:start_worker_thread)
     self.expects(:install_exit_handler)
-    check_config_and_start_agent
+    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
@@ -103,8 +132,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   private :at_exit
 
   def test_install_exit_handler_positive
-    control = mocked_control
-    control.expects(:send_data_on_exit).returns(true)
     NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
     NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
     self.expects(:using_sinatra?).returns(false)
@@ -112,27 +139,30 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     # test the shutdown logic. It's somewhat unfortunate, but we can't
     # kill the interpreter during a test.
     self.expects(:shutdown)
-    install_exit_handler
+    with_config(:send_data_on_exit => true) do
+      install_exit_handler
+    end
   end
 
   def test_install_exit_handler_negative
-    control = mocked_control
-    control.expects(:send_data_on_exit).returns(false)
-    install_exit_handler
+    with_config(:send_data_on_exit => false) do
+      install_exit_handler
+    end
+    # should not raise excpetion
   end
 
   def test_install_exit_handler_weird_ruby
-    control = mocked_control
-    control.expects(:send_data_on_exit).times(3).returns(true)
-    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
+    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_notify_log_file_location_positive
@@ -149,32 +179,32 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_monitoring_positive
-    control = mocked_control
-    control.expects(:monitor_mode?).returns(true)
-    log = mocked_log
-    assert monitoring?
+    with_config(:monitor_mode => true) do
+      log = mocked_log
+      assert monitoring?
+    end
   end
 
   def test_monitoring_negative
-    control = mocked_control
     log = mocked_log
-    control.expects(:monitor_mode?).returns(false)
-    log.expects(:send).with(:warn, "Agent configured not to send data in this environment - edit newrelic.yml to change this")
-    assert !monitoring?
+    with_config(:monitor_mode => false) do
+      log.expects(:send).with(:warn, "Agent configured not to send data in this environment.")
+      assert !monitoring?
+    end
   end
 
   def test_has_license_key_positive
-    control = mocked_control
-    control.expects(:license_key).returns("a" * 40)
-    assert has_license_key?
+    with_config(:license_key => 'a' * 40) do
+      assert has_license_key?
+    end
   end
 
   def test_has_license_key_negative
-    control = mocked_control
-    control.expects(:license_key).returns(nil)
-    log = mocked_log
-    log.expects(:send).with(:error, 'No license key found.  Please edit your newrelic.yml file and insert your license key.')
-    assert !has_license_key?
+    with_config(:license_key => false) do
+      log = mocked_log
+      log.expects(:send).with(:warn, 'No license key found in newrelic.yml config.')
+      assert !has_license_key?
+    end
   end
 
   def test_has_correct_license_key_positive
@@ -189,31 +219,31 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_correct_license_length_positive
-    control = mocked_control
-    control.expects(:license_key).returns("a" * 40)
-    assert correct_license_length
+    with_config(:license_key => 'a' * 40) do
+      assert correct_license_length
+    end
   end
 
   def test_correct_license_length_negative
-    control = mocked_control
-    log = mocked_log
-    control.expects(:license_key).returns("a"*30)
-    log.expects(:send).with(:error, "Invalid license key: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
-    assert !correct_license_length
+    with_config(:license_key => 'a' * 30) do
+      log = mocked_log
+      log.expects(:send).with(:error, "Invalid license key: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+      assert !correct_license_length
+    end
   end
 
   def test_using_forking_dispatcher_positive
-    control = mocked_control
-    control.expects(:dispatcher).returns(:passenger)
-    log = mocked_log
-    log.expects(:send).with(:info, "Connecting workers after forking.")
-    assert using_forking_dispatcher?
+    with_config(:dispatcher => :passenger) do
+      log = mocked_log
+      log.expects(:send).with(:info, "Connecting workers after forking.")
+      assert using_forking_dispatcher?
+    end
   end
 
   def test_using_forking_dispatcher_negative
-    control = mocked_control
-    control.expects(:dispatcher).returns(:frobnitz)
-    assert !using_forking_dispatcher?
+    with_config(:dispatcher => :frobnitz) do
+      assert !using_forking_dispatcher?
+    end
   end
 
   def test_log_unless_positive