newrelic_rpm 3.4.1 → 3.4.2.beta1

data/lib/new_relic/rack/browser_monitoring.rb

@@ -44,25 +44,37 @@ module NewRelic::Rack
         footer = NewRelic::Agent.browser_timing_footer
         header = NewRelic::Agent.browser_timing_header
 
-        head_pos = if beginning_of_source.include?('X-UA-Compatible')
-          # put at end of header if UA-Compatible meta tag found
+        x_ua_compatible_found = beginning_of_source.include?('X-UA-Compatible')
+
+        head_pos = if x_ua_compatible_found
+          # put at end of header if X-UA-Compatible meta tag found
+          NewRelic::Agent.logger.debug "Detected X-UA-Compatible meta tag. Attempting to insert RUM header at end of head."
           beginning_of_source.index("</head>")
-       elsif head_open = beginning_of_source.index("<head")
+        elsif head_open = beginning_of_source.index("<head")
+          NewRelic::Agent.logger.debug "Attempting to insert RUM header at beginning of head."
           # put at the beginning of the header
           beginning_of_source.index(">", head_open) + 1
+        else
+          NewRelic::Agent.logger.debug "Failed to detect head tag. Attempting to insert RUM header at above body tag."
+          # otherwise put the header right above body start
+          body_start
         end
-        # otherwise put the header right above body start
-        head_pos ||= body_start
 
         # check that head_pos is less than body close.  If it's not something
         # is really weird and we should punt.
-        if head_pos < body_close
+        if head_pos && (head_pos < body_close)
           # rebuild the source
           source = source[0..(head_pos-1)] <<
             header <<
             source[head_pos..(body_close-1)] <<
             footer <<
             source[body_close..-1]
+        else
+          if head_pos
+            NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Failed to detect head tags."
+          else
+            NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Detected head is after detected body close."
+          end
         end
       end
       headers['Content-Length'] = source.length.to_s if headers['Content-Length']

data/lib/new_relic/version.rb

@@ -3,8 +3,8 @@ module NewRelic
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 4
-    TINY  = 1
-    BUILD = nil # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    TINY  = 2
+    BUILD = 'beta1' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 

data/newrelic.yml

@@ -209,10 +209,6 @@ common: &default_settings
   # overhead slightly on every memcached call, and can have security
   # implications if your memcached keys are sensitive
   # capture_memcache_keys: true
-  
-  # Certain types of instrumentation such as GC stats will not work if 
-  # you are running multi-threaded.  Please let us know.
-  # multi_threaded = false
 
 # Application Environments
 # ------------------------------------------

data/newrelic_rpm.gemspec

@@ -5,13 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = "newrelic_rpm"
-  s.version = "3.4.1"
+  s.version = "3.4.2.beta1"
 
-  s.authors = ["Bill Kayser", "Jon Guymon", "Justin George", "Darin Swanson"]
-  s.date = "2012-07-26"
+  s.authors = ["Bill Kayser", "Jon Guymon", "Justin George", "Darin Swanson", "Rob Saul"]
+  s.date = "2012-08-31"
   s.description = "New Relic is a performance management system, developed by New Relic,\nInc (http://www.newrelic.com).  New Relic provides you with deep\ninformation about the performance of your web application as it runs\nin production. The New Relic Ruby Agent is dual-purposed as a either a\nGem or plugin, hosted on\nhttp://github.com/newrelic/rpm/\n"
   s.email = "support@newrelic.com"
-  s.executables = ["mongrel_rpm", "newrelic_cmd", "newrelic"]
+  s.executables = ["newrelic", "mongrel_rpm", "newrelic_cmd"]
   s.extra_rdoc_files = [
     "CHANGELOG",
     "LICENSE",
@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
     "CHANGELOG",
     "LICENSE",
     "README.rdoc",
+    "ReleaseNotes.md",
     "bin/mongrel_rpm",
     "bin/newrelic",
     "bin/newrelic_cmd",
@@ -37,6 +38,12 @@ Gem::Specification.new do |s|
     "lib/new_relic/agent/browser_monitoring.rb",
     "lib/new_relic/agent/busy_calculator.rb",
     "lib/new_relic/agent/chained_call.rb",
+    "lib/new_relic/agent/configuration.rb",
+    "lib/new_relic/agent/configuration/defaults.rb",
+    "lib/new_relic/agent/configuration/environment_source.rb",
+    "lib/new_relic/agent/configuration/manager.rb",
+    "lib/new_relic/agent/configuration/server_source.rb",
+    "lib/new_relic/agent/configuration/yaml_source.rb",
     "lib/new_relic/agent/database.rb",
     "lib/new_relic/agent/error_collector.rb",
     "lib/new_relic/agent/instrumentation.rb",
@@ -91,7 +98,6 @@ Gem::Specification.new do |s|
     "lib/new_relic/commands/install.rb",
     "lib/new_relic/control.rb",
     "lib/new_relic/control/class_methods.rb",
-    "lib/new_relic/control/configuration.rb",
     "lib/new_relic/control/frameworks.rb",
     "lib/new_relic/control/frameworks/external.rb",
     "lib/new_relic/control/frameworks/merb.rb",
@@ -148,6 +154,10 @@ Gem::Specification.new do |s|
     "test/new_relic/agent/beacon_configuration_test.rb",
     "test/new_relic/agent/browser_monitoring_test.rb",
     "test/new_relic/agent/busy_calculator_test.rb",
+    "test/new_relic/agent/configuration/environment_source_test.rb",
+    "test/new_relic/agent/configuration/manager_test.rb",
+    "test/new_relic/agent/configuration/server_source_test.rb",
+    "test/new_relic/agent/configuration/yaml_source_test.rb",
     "test/new_relic/agent/database_test.rb",
     "test/new_relic/agent/error_collector/notice_error_test.rb",
     "test/new_relic/agent/error_collector_test.rb",
@@ -184,7 +194,7 @@ Gem::Specification.new do |s|
     "test/new_relic/collection_helper_test.rb",
     "test/new_relic/command/deployments_test.rb",
     "test/new_relic/control/class_methods_test.rb",
-    "test/new_relic/control/configuration_test.rb",
+    "test/new_relic/control/frameworks/rails_test.rb",
     "test/new_relic/control/logging_methods_test.rb",
     "test/new_relic/control_test.rb",
     "test/new_relic/delayed_job_injection_test.rb",

data/test/config/newrelic.yml

@@ -44,5 +44,6 @@ test:
   error_collector:
     enabled: true
     capture_source: true
-    
-  
+
+development:
+  host: the.wrong.host

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)
   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)
@@ -224,19 +214,18 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_config_transaction_tracer
-    NewRelic::Control.instance.settings['transaction_tracer'] = {
-      'enabled' => true,
-      'random_sample' => false,
-      'explain_threshold' => 0.75,
-      'explain_enabled' => true
+    test_config = {
+      'transaction_tracer.enabled' => true,
+      'transaction_tracer.random_sampler' => false,
+      'transaction_tracer.explain_threshold' => 0.75,
+      'transaction_tracer.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
+    with_config(test_config) do
+      config_transaction_tracer
+      assert @transaction_sampler.enabled?
+      assert_equal 0.75, @transaction_sampler.explain_threshold
+      assert @transaction_sampler.explain_enabled
+    end
   end
 
   def test_configure_transaction_tracer_with_random_sampling
@@ -274,53 +263,49 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   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
+      self.expects(:log_sql_transmission_warning?)
+      set_sql_recording!
+      assert_equal :obfuscated, @record_sql, " should default to :obfuscated, was #{@record_sql}"
+    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
+      self.expects(:log_sql_transmission_warning?)
+      set_sql_recording!
+      assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+    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
+      self.expects(:log_sql_transmission_warning?)
+      set_sql_recording!
+      assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+    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
+      self.expects(:log_sql_transmission_warning?)
+      set_sql_recording!
+      assert_equal :raw, @record_sql, "should be set to :raw, was #{@record_sql}"
+    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}"
+    with_config(:'transaction_tracer.record_sql' => false) do
+      self.expects(:log_sql_transmission_warning?)
+      set_sql_recording!
+      assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+    end
   end
 
   def test_log_sql_transmission_warning_negative
@@ -366,17 +351,18 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
       'collect_errors' => true,
       'sample_rate' => 10
     }
-    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 'pasta sauce', @report_period
+      assert_equal 'tamales', @url_rules
+    end
   end
 
   def test_finish_setup_without_config
@@ -385,6 +371,25 @@ 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,
+        'listen_to_server_config' => true
+      }
+      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

@@ -16,39 +16,39 @@ 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
+    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_check_config_and_start_agent_disabled
@@ -70,26 +70,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 +97,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 +104,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 +144,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 - edit newrelic.yml to change this")
+      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(:error, 'No license key found.  Please edit your newrelic.yml file and insert your license key.')
+      assert !has_license_key?
+    end
   end
 
   def test_has_correct_license_key_positive
@@ -189,31 +184,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