wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/agent/worker_loop_test.rb

@@ -3,10 +3,7 @@ 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
 
@@ -19,11 +16,28 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     assert @x
   end
 
+  def test_with_duration
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.1)
+    count = 0
+    worker_loop.run(0.04) do
+      count += 1
+    end
+
+    assert_equal 2, count
+  end
+
+  def test_loop_limit
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 2)
+    iterations = 0
+    worker_loop.run(0) { iterations += 1 }
+    assert_equal 2, iterations
+  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
+    @worker_loop.run(0.03) do
       count +=1
       if count == 3
         @worker_loop.stop
@@ -31,11 +45,11 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
       end
     end
     elapsed = Time.now - start
-    assert_in_delta 0.03, elapsed, 0.02
+    assert_in_delta 0.09, elapsed, 0.03
   end
+
   def test_task_error__standard
-    @logger.expects(:debug)
-    @logger.expects(:error)
+    expects_logging(:error, any_parameters)
     # This loop task will run twice
     done = false
     @worker_loop.run(0) do
@@ -45,19 +59,20 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     end
     assert done
   end
+
   class BadBoy < StandardError; end
 
   def test_task_error__exception
-    @logger.expects(:error).once
-    @logger.expects(:debug).once
+    expects_logging(:error, any_parameters)
     @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
+    expects_no_logging(:error, any_parameters)
+    expects_logging(:debug, any_parameters)
     @worker_loop.run(0) do
       @worker_loop.stop
       raise NewRelic::Agent::ServerError, "Runtime Error Test"

data/test/new_relic/agent_test.rb

@@ -1,28 +1,105 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'ostruct'
+
 module NewRelic
+  # mostly this class just passes through to the active agent
+  # through the agent method or the control instance through
+  # NewRelic::Control.instance . But it's nice to make sure.
   class MainAgentTest < Test::Unit::TestCase
-    
-    # mostly this module just passes through to the active agent
-    # through the agent method or the control instance through
-    # NewRelic::Control.instance . But it's nice to make sure.
+
+    def setup
+      NewRelic::Agent.reset_config
+    end
 
     def teardown
       super
       Thread.current[:newrelic_untraced] = nil
     end
-    
+
     def test_shutdown
       mock_agent = mocked_agent
       mock_agent.expects(:shutdown).with({})
       NewRelic::Agent.shutdown
     end
 
+    def test_shutdown_removes_manual_startup_config
+      NewRelic::Agent.manual_start(:some_absurd_setting => true)
+      assert NewRelic::Agent.config[:some_absurd_setting]
+      NewRelic::Agent.shutdown
+      assert !NewRelic::Agent.config[:some_absurd_setting]
+    end
+
+    def test_shutdown_removes_server_config
+      NewRelic::Agent.manual_start
+      NewRelic::Agent.instance.finish_setup('agent_config' =>
+                                            { :some_absurd_setting => true })
+      assert NewRelic::Agent.config[:some_absurd_setting]
+      NewRelic::Agent.shutdown
+      assert !NewRelic::Agent.config[:some_absurd_setting]
+    end
+
+    def test_finish_setup_applied_server_side_config
+      with_config({ :'transction_tracer.enabled' => true,
+                    'error_collector.enabled' => true,
+                    :log_level => 'info' }, 2) do
+        NewRelic::Agent.instance.finish_setup('log_level' => 'debug',
+         'agent_config' => { 'transaction_tracer.enabled' => false },
+                                         'collect_errors' => false)
+        assert !NewRelic::Agent.config[:'transaction_tracer.enabled']
+        assert !NewRelic::Agent.config[:'error_collector.enabled']
+        assert_equal 'debug', NewRelic::Agent.config[:log_level]
+      end
+    end
+
     def test_after_fork
       mock_agent = mocked_agent
       mock_agent.expects(:after_fork).with({})
       NewRelic::Agent.after_fork
     end
-    
+
+    def test_after_fork_sets_forked_flag
+      agent = NewRelic::Agent::Agent.new
+      assert !agent.forked?
+      agent.after_fork
+
+      assert agent.forked?
+    end
+
+    if NewRelic::LanguageSupport.can_fork? &&
+        !NewRelic::LanguageSupport.using_version?('1.9.1')
+      def test_timeslice_harvest_with_after_fork_report_to_channel
+        with_config(:agent_enabled => true, :monitor_mode => true) do
+          NewRelic::Agent.shutdown # make sure the agent is not already started
+          NewRelic::Agent::Agent.instance.service = NewRelic::FakeService.new
+          NewRelic::Agent.manual_start(:license_key => ('1234567890' * 4),
+                                       :start_channel_listener => true)
+
+          metric = 'Custom/test/method'
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric) \
+            .record_data_point(1.0)
+
+          # ensure that cached metric ids don't interfere with metric merging
+          NewRelic::Agent.agent.instance_variable_set(:@metric_ids,
+                            { NewRelic::MetricSpec.new('Instance/Busy') => 1 })
+
+          NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+          NewRelic::Agent.register_report_channel(:agent_test) # before fork
+          pid = Process.fork do
+            NewRelic::Agent.after_fork(:report_to_channel => :agent_test)
+            NewRelic::Agent.agent.stats_engine.get_stats_no_scope(metric) \
+              .record_data_point(2.0)
+          end
+          Process.wait(pid)
+          NewRelic::Agent::PipeChannelManager.listener.stop
+
+          engine = NewRelic::Agent.agent.stats_engine
+          assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
+          assert_equal(2, engine.lookup_stats(metric).call_count)
+          engine.reset_stats
+        end
+      end
+    end
+
     def test_reset_stats
       mock_agent = mocked_agent
       mock_agent.expects(:reset_stats)
@@ -34,17 +111,20 @@ module NewRelic
       mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => true})
       NewRelic::Agent.manual_start
     end
-    
+
     def test_manual_start_with_opts
       mock_control = mocked_control
       mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => false})
       NewRelic::Agent.manual_start(:sync_startup => false)
     end
 
-    def test_logger
-      control = mocked_control
-      control.expects(:log)
-      NewRelic::Agent.logger
+    def test_manual_start_starts_channel_listener
+      NewRelic::Agent::PipeChannelManager.listener.stop
+      NewRelic::Agent.agent.service = NewRelic::FakeService.new
+      NewRelic::Agent.manual_start(:start_channel_listener => true)
+      assert NewRelic::Agent::PipeChannelManager.listener.started?
+      NewRelic::Agent::PipeChannelManager.listener.stop
+      NewRelic::Agent.shutdown
     end
 
     def test_browser_timing_header
@@ -66,7 +146,7 @@ module NewRelic
       mock_stats_engine.expects(:get_stats).with('Custom/test/metric', false)
       NewRelic::Agent.get_stats('Custom/test/metric')
     end
-    
+
     # note that this is the same as get_stats above, they're just aliases
     def test_get_stats_no_scope
       agent = mocked_agent
@@ -111,7 +191,7 @@ module NewRelic
       Thread.current[:record_tt] = false
       assert_equal(false, NewRelic::Agent.is_transaction_traced?, 'should be false since the thread local is false')
     end
-    
+
     def test_is_sql_recorded_true
       Thread.current[:record_sql] = true
       assert_equal(true, NewRelic::Agent.is_sql_recorded?, 'should be true since the thread local is set')
@@ -126,7 +206,7 @@ module NewRelic
       Thread.current[:record_sql] = false
       assert_equal(false, NewRelic::Agent.is_sql_recorded?, 'should be false since the thread local is false')
     end
-    
+
     def test_is_execution_traced_true
       Thread.current[:newrelic_untraced] = [true, true]
       assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is set')
@@ -146,28 +226,16 @@ module NewRelic
       Thread.current[:newrelic_untraced] = [true, false]
       assert_equal(false, NewRelic::Agent.is_execution_traced?, 'should be false since the thread local stack has the last element false')
     end
-    
+
     def test_instance
       assert_equal(NewRelic::Agent.agent, NewRelic::Agent.instance, "should return the same agent for both identical methods")
     end
 
-    def test_load_data_should_disable_serialization_if_an_error_is_encountered
-      NewRelic::Control.instance['disable_serialization'] = false
-      NewRelic::DataSerialization.stubs(:should_send_data?).returns(false)
-      NewRelic::Agent.stubs(:save_data).raises(Errno::EACCES)
-      begin
-        NewRelic::Agent.instance.send(:save_or_transmit_data)
-      rescue Errno::EACCES; end
-      # should be true
-      assert(NewRelic::Control.instance['disable_serialization'])
-      NewRelic::Control.instance['disable_serialization'] = false
-    end
-
-    def test_load_data_should_not_write_files_when_serialization_disabled
-      NewRelic::Control.instance['disable_serialization'] = true
-      NewRelic::DataSerialization.expects(:read_and_write_to_file).never
-      NewRelic::Agent.load_data
-      NewRelic::Control.instance['disable_serialization'] = false
+    def test_register_report_channel
+      NewRelic::Agent.register_report_channel(:channel_id)
+      assert NewRelic::Agent::PipeChannelManager.channels[:channel_id] \
+        .kind_of?(NewRelic::Agent::PipeChannelManager::Pipe)
+      NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
     end
 
     private
@@ -179,7 +247,19 @@ module NewRelic
     end
 
     def mocked_control
-      control = mock('control')
+      server = NewRelic::Control::Server.new('localhost', 3000)
+      control = OpenStruct.new(:license_key => 'abcdef',
+                               :server => server)
+      control.instance_eval do
+        def [](key)
+          nil
+        end
+
+        def fetch(k,d)
+          nil
+        end
+      end
+
       NewRelic::Control.stubs(:instance).returns(control)
       control
     end

data/test/new_relic/collection_helper_test.rb

@@ -24,7 +24,7 @@ class NewRelic::CollectionHelperTest < Test::Unit::TestCase
     assert_equal '1000', new_array[0]
   end
   def test_boolean
-    np = normalize_params(NewRelic::Control.instance.settings)
+    np = normalize_params('monitor_mode' => false)
     assert_equal false, np['monitor_mode']
   end
   def test_string__singleton
@@ -118,14 +118,13 @@ class NewRelic::CollectionHelperTest < Test::Unit::TestCase
   end
 
   def test_disabled_strip_backtrace
-    NewRelic::Control.instance['disable_backtrace_cleanup'] = true
-    clean_trace = strip_nr_from_backtrace(mock_backtrace)
-    assert_equal(1, clean_trace.grep(/new_relic/).size,
-            "should not remove instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
-    assert_equal(1, clean_trace.grep(/_trace/).size, 
+    with_config(:disable_backtrace_cleanup => true) do
+      clean_trace = strip_nr_from_backtrace(mock_backtrace)
+      assert_equal(1, clean_trace.grep(/new_relic/).size,
+                   "should not remove instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
+      assert_equal(1, clean_trace.grep(/_trace/).size,
                    "should not remove trace method tags from method names but got: #{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")}"
-    NewRelic::Control.instance['disable_backtrace_cleanup'] = false
+    end
   end
   
   private 

data/test/new_relic/command/deployments_test.rb

@@ -10,6 +10,8 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
       def info(message); @messages = @messages ? @messages + message : message; end
       def just_exit(status=0); @exit_status ||= status; end
     end
+    @config = { :license_key => 'a' * 40 }
+    NewRelic::Agent.config.apply_config(@config)
   end
   def teardown
     super
@@ -17,6 +19,7 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
     puts @deployment.errors
     puts @deployment.messages
     puts @deployment.exit_status
+    NewRelic::Agent.config.remove_config(@config)
   end
   def test_help
     begin
@@ -33,7 +36,10 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
   end
   def test_interactive
     mock_the_connection
-    @deployment = NewRelic::Command::Deployments.new :appname => 'APP', :revision => 3838, :user => 'Bill', :description => "Some lengthy description"
+    @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
@@ -56,7 +62,18 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
 
     @deployment = nil
   end
+
+  def test_error_if_no_license_key
+    with_config(:license_key => '') do
+      assert_raise NewRelic::Command::CommandFailure do
+      deployment = NewRelic::Command::Deployments.new(%w[-a APP -r 3838 --user=Bill] << "Some lengthy description")
+        deployment.run
+      end
+    end
+  end
+
   private
+
   def mock_the_connection
     mock_connection = mock()
     @mock_response = mock()
@@ -64,5 +81,4 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
     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

@@ -18,24 +18,6 @@ class NewRelic::Control::ClassMethodsTest < Test::Unit::TestCase
     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

data/test/new_relic/control/frameworks/rails_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../../../test_helper'))
+
+class NewRelic::Control::Frameworks::RailsTest < Test::Unit::TestCase
+  def test_install_browser_monitoring
+    require(File.expand_path(File.join(File.dirname(__FILE__),
+                         '/../../../../lib/new_relic/rack/browser_monitoring')))
+    middleware = stub('middleware config')
+    config = stub('rails config', :middleware => middleware)
+    middleware.expects(:use).with(NewRelic::Rack::BrowserMonitoring)
+    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
+    with_config(:'browser_monitoring.auto_instrument' => true) do
+      NewRelic::Control.instance.install_browser_monitoring(config)
+    end
+  end
+
+  def test_install_browser_monitoring_should_not_install_when_not_configured
+    middleware = stub('middleware config')
+    config = stub('rails config', :middleware => middleware)
+    middleware.expects(:use).never
+    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
+
+    with_config(:'browser_monitoring.auto_instrument' => false) do
+      NewRelic::Control.instance.install_browser_monitoring(config)
+    end
+  end
+end

data/test/new_relic/control_test.rb

@@ -1,10 +1,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
-class NewRelic::ControlTest < Test::Unit::TestCase
 
+class NewRelic::ControlTest < Test::Unit::TestCase
   attr_reader :control
 
   def setup
-    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
     @control =  NewRelic::Control.instance
     raise 'oh geez, wrong class' unless NewRelic::Control.instance.is_a?(::NewRelic::Control::Frameworks::Test)
   end
@@ -17,12 +16,11 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert @control.cert_file_path
     assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @control.cert_file_path
   end
-  
+
   # This test does not actually use the ruby agent in any way - it's
   # testing that the CA file we ship actually validates our server's
   # certificate. It's used for customers who enable verify_certificate
   def test_cert_file
-    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
@@ -34,12 +32,11 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     s.connect
     # should not raise an error
   end
-  
+
   # see above, but for staging, as well. This allows us to test new
   # certificates in a non-customer-facing place before setting them
   # live.
   def test_staging_cert_file
-    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
@@ -52,39 +49,21 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     # should not raise an error
   end
 
-  def test_monitor_mode
-    assert ! @control.monitor_mode?
-    @control.settings.delete 'enabled'
-    @control.settings.delete 'monitor_mode'
-    assert !@control.monitor_mode?
-    @control['enabled'] = false
-    assert ! @control.monitor_mode?
-    @control['enabled'] = true
-    assert @control.monitor_mode?
-    @control['monitor_mode'] = nil
-    assert !@control.monitor_mode?
-    @control['monitor_mode'] = false
-    assert !@control.monitor_mode?
-    @control['monitor_mode'] = true
-    assert @control.monitor_mode?
-  ensure
-    @control['enabled'] = false
-    @control['monitor_mode'] = false
-  end
-
   def test_test_config
-    if defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
+    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+      assert_equal :rails4, control.app
+    elsif defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
       assert_equal :rails3, control.app
-    elsif defined?(Rails)
+    elsif defined?(::Rails)
       assert_equal :rails, control.app
     else
       assert_equal :test, control.app
     end
     assert_equal :test, control.framework
-    assert_match /test/i, control.dispatcher_instance_id
-    assert("" == control.dispatcher.to_s, "Expected dispatcher to be empty, but was #{control.dispatcher.to_s}")
-    assert !control['enabled']
-    assert_equal false, control['monitor_mode']
+    assert_match /test/i, control.local_env.dispatcher_instance_id
+    assert("" == NewRelic::Agent.config[:dispatcher].to_s,
+           "Expected dispatcher to be empty, but was #{NewRelic::Agent.config[:dispatcher].to_s}")
+    assert !NewRelic::Agent.config[:monitor_mode]
     control.local_env
   end
 
@@ -96,19 +75,58 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_info
+    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
     props = NewRelic::Control.instance.local_env.snapshot
     if defined?(Rails)
       assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last, props.inspect
     end
   end
 
-  def test_resolve_ip
+  def test_resolve_ip_for_localhost
     assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+  end
+
+  def test_resolve_ip_for_non_existent_domain
+    Resolv.stubs(:getaddress).raises(Resolv::ResolvError)
+    IPSocket.stubs(:getaddress).raises(SocketError)
     assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
-    # This will fail if you don't have a valid, accessible, DNS server
+  end
+
+  def test_resolves_valid_ip
+    Resolv.stubs(:getaddress).with('collector.newrelic.com').returns('204.93.223.153')
     assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
   end
 
+  def test_do_not_resolve_if_we_need_to_verify_a_cert
+    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    with_config(:ssl => true, :verify_certificate => true) do
+      assert_equal 'localhost', control.send(:convert_to_ip_address, 'localhost')
+    end
+  end
+
+  def test_api_server_uses_configured_values
+    control.instance_variable_set(:@api_server, nil)
+    with_config(:api_host => 'somewhere', :api_port => 8080) do
+      assert_equal 'somewhere', control.api_server.name
+      assert_equal 8080, control.api_server.port
+    end
+  end
+
+  def test_proxy_server_uses_configured_values
+    control.instance_variable_set(:@proxy_server, nil)
+    with_config(:proxy_host => 'proxytown', :proxy_port => 81) do
+      assert_equal 'proxytown', control.proxy_server.name
+      assert_equal 81, control.proxy_server.port
+    end
+  end
+
+  def test_server_from_host_uses_configured_values
+    with_config(:host => 'donkeytown', :port => 8080) do
+      assert_equal 'donkeytown', control.server_from_host.name
+      assert_equal 8080, control.server_from_host.port
+    end
+  end
+
   class FakeResolv
     def self.getaddress(host)
       raise 'deliberately broken'
@@ -131,126 +149,67 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert_equal old_ipsocket, IPSocket
   end
 
-  def test_config_yaml_erb
-    assert_equal 'heyheyhey', control['erb_value']
-    assert_equal '', control['message']
-    assert_equal '', control['license_key']
-  end
-
-  def test_appnames
-    assert_equal %w[a b c], NewRelic::Control.instance.app_names
-  end
-
-  def test_config_booleans
-    assert_equal control['tval'], true
-    assert_equal control['fval'], false
-    assert_nil control['not_in_yaml_val']
-    assert_equal control['yval'], true
-    assert_equal control['sval'], 'sure'
-  end
-
-  def test_config_apdex
-    assert_equal 1.1, control.apdex_t
-  end
-
-#  def test_transaction_threshold
-#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
-#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-#  end
-
-  def test_log_file_name
-    NewRelic::Control.instance.setup_log
-    assert_match /newrelic_agent.log$/, control.instance_variable_get('@log_file')
-  end
-
-#  def test_transaction_threshold__apdex
-#    forced_start
-#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
-#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-#  end
-
-  def test_transaction_threshold__default
-    forced_start :transaction_tracer => { :transaction_threshold => nil}
-    assert_nil control['transaction_tracer']['transaction_threshold']
-    assert_equal 2.0, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-  end
-
   def test_transaction_threshold__override
-    forced_start :transaction_tracer => { :transaction_threshold => 1}
-    assert_equal 1, control['transaction_tracer']['transaction_threshold']
-    assert_equal 1, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+    with_config(:transaction_tracer => { :transaction_threshold => 1}) do
+      assert_equal 1, NewRelic::Agent.config[:'transaction_tracer.transaction_threshold']
+    end
   end
 
   def test_transaction_tracer_disabled
-    forced_start(:transaction_tracer => { :enabled => false },
-                 :developer_mode => false, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_transaction_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
-           'transaction tracer enabled when config calls for disabled')
-    
-    @control['developer_mode'] = true
-    @control['monitor_mode'] = false
+    with_config(:'transaction_tracer.enabled' => false,
+                :developer_mode => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
+             'transaction tracer enabled when config calls for disabled')
+    end
   end
-  
+
   def test_sql_tracer_disabled
-    forced_start(:slow_sql => { :enabled => false }, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql tracer enabled when config calls for disabled')
-    
-    @control['monitor_mode'] = false
+    with_config(:'slow_sql.enabled' => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql tracer enabled when config calls for disabled')
+    end
   end
-  
+
   def test_sql_tracer_disabled_with_record_sql_false
-    forced_start(:slow_sql => { :enabled => true, :record_sql => 'off' })
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql tracer enabled when config calls for disabled')
+    with_config(:slow_sql => { :enabled => true, :record_sql => 'off' }) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql tracer enabled when config calls for disabled')
+    end
   end
 
   def test_sql_tracer_disabled_when_tt_disabled
-    forced_start(:transaction_tracer => { :enabled => false },
-                 :slow_sql => { :enabled => true },
-                 :developer_mode => false, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql enabled when transaction tracer disabled')
-    
-    @control['developer_mode'] = true
-    @control['monitor_mode'] = false    
+    with_config(:'transaction_tracer.enabled' => false,
+                :'slow_sql.enabled' => true,
+                :developer_mode => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql enabled when transaction tracer disabled')
+    end
   end
 
   def test_sql_tracer_disabled_when_tt_disabled_by_server
-    forced_start(:slow_sql => { :enabled => true },
-                 :transaction_tracer => { :enabled => true },
-                 :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    NewRelic::Agent::Agent.instance.finish_setup('collect_traces' => false)    
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql enabled when tracing disabled by server')
-    
-    @control['monitor_mode'] = false        
-  end
+    with_config({:'slow_sql.enabled' => true,
+                  :'transaction_tracer.enabled' => true,
+                  :monitor_mode => true}, 2) do
+      NewRelic::Agent.instance.finish_setup('collect_traces' => false)
 
-  def test_merging_options
-    NewRelic::Control.send :public, :merge_options
-    @control.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
-    assert_equal 66, NewRelic::Control.instance['api_port']
-    assert_equal 2.0, NewRelic::Control.instance['transaction_tracer']['explain_threshold']
-    assert_equal 'raw', NewRelic::Control.instance['transaction_tracer']['record_sql']
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql enabled when tracing disabled by server')
+    end
   end
 
-  private
+  def test_init_plugin_loads_samplers_enabled
+    NewRelic::Agent.shutdown
+    with_config(:disable_samplers => false, :agent_enabled => true) do
+      NewRelic::Control.instance.init_plugin
+      assert NewRelic::Agent.instance.stats_engine.send(:harvest_samplers).any?
+    end
+  end
 
-  def forced_start overrides = {}
-    NewRelic::Agent.manual_start overrides
-    # This is to force the agent to start again.
-    NewRelic::Agent.instance.stubs(:started?).returns(nil)
-    NewRelic::Agent.instance.start
+  def test_init_plugin_loads_samplers_disabled
+    NewRelic::Agent.shutdown
+    with_config(:disable_samplers => true, :agent_enabled => true) do
+      NewRelic::Control.instance.init_plugin
+      assert NewRelic::Agent.instance.stats_engine.send(:harvest_samplers).empty?
+    end
   end
 end