newrelic_rpm 3.12.0.288 → 9.10.2

data/test/new_relic/coerce_test.rb

@@ -1,95 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
-require 'new_relic/coerce'
-
-class CoerceTest < Minitest::Test
-
-  include NewRelic::Coerce
-
-  def test_int_coerce
-    assert_equal 1, int(1)
-    assert_equal 1, int("1")
-    assert_equal 1, int(1.0)
-    assert_equal 1, int(Rational(1, 1))
-    assert_equal 0, int("invalid")
-    assert_equal 0, int(nil)
-
-    # http://ruby-doc.org/core-1.8.7/Symbol.html#method-i-to_i
-    assert_equal 0, int(:wat) unless RUBY_VERSION < '1.9'
-  end
-
-  def test_int_coerce_logs
-    expects_logging(:warn, Not(includes("context")), any_parameters)
-    int("not valid")
-  end
-
-  def test_int_coerce_logs_with_context
-    expects_logging(:warn, all_of(includes("HERE"), includes("Integer")), anything)
-    int("not valid", "HERE")
-  end
-
-  def test_int_coerce_or_nil
-    assert_equal 1, int_or_nil(1)
-    assert_equal 1, int_or_nil("1")
-    assert_equal 1, int_or_nil(1.0)
-    assert_equal 1, int_or_nil(Rational(1, 1))
-    assert_equal nil, int_or_nil("invalid")
-    assert_equal nil, int_or_nil(nil)
-  end
-
-  def test_int_or_nil_coerce_logs_with_context
-    expects_logging(:warn, all_of(includes("HERE"), includes("Integer")), anything)
-    int_or_nil("not valid", "HERE")
-  end
-
-  def test_float_coerce
-    assert_equal 1.0, float(1.0)
-    assert_equal 1.0, float("1.0")
-    assert_equal 1.0, float(1)
-    assert_equal 1.0, float(Rational(1, 1))
-    assert_equal 0.0, float("invalid")
-    assert_equal 0.0, float(nil)
-    assert_equal 0.0, float(:symbols_are_fun)
-  end
-
-  def test_float_coerce_logs_with_context
-    expects_logging(:warn, all_of(includes("HERE"), includes("Float")), anything)
-    float("not valid", "HERE")
-  end
-
-  def test_float_coerce_with_infinite_value_logs_and_returns_0_0
-    expects_logging(:warn, all_of(includes("TestingInfinity"), includes("Float"), includes("'Infinity'")), anything)
-    infinity = 1337807.0/0.0
-    result = float(infinity, "TestingInfinity")
-    assert_equal 0.0, result
-  end
-
-  def test_float_coerce_with_nan_value_logs_and_returns_0_0
-    expects_logging(:warn, all_of(includes("TestingNaN"), includes("Float"), includes("'NaN'")), anything)
-    nan = 0.0/0.0
-    result = float(nan, "TestingNaN")
-    assert_equal 0.0, result
-  end
-
-  def test_string_coerce
-    assert_equal "1",      string(1)
-    assert_equal "1.0",    string(1.0)
-    assert_equal "string", string("string")
-    assert_equal "1/100",  string(Rational(1, 100))
-    assert_equal "yeah",   string(:yeah)
-    assert_equal nil,      string(nil)
-    assert_equal "",       string(Unstringable.new)
-  end
-
-  def test_string_coerce_logs_with_context
-    expects_logging(:warn, all_of(includes("HERE"), includes("String")), anything)
-    string(Unstringable.new, "HERE")
-  end
-
-  class Unstringable
-    undef :to_s
-  end
-end

data/test/new_relic/collection_helper_test.rb

@@ -1,151 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
-require 'ostruct'
-
-require 'new_relic/collection_helper'
-class NewRelic::CollectionHelperTest < Minitest::Test
-
-  def setup
-    NewRelic::Agent.manual_start
-    super
-  end
-  def teardown
-    super
-  end
-
-  include NewRelic::CollectionHelper
-  def test_string
-    val = (('A'..'Z').to_a.join * 1024).to_s
-    assert_equal val[0...16384] + "...", normalize_params(val)
-  end
-  def test_array
-    new_array = normalize_params [ 1000 ] * 2000
-    assert_equal 128, new_array.size
-    assert_equal '1000', new_array[0]
-  end
-  def test_boolean
-    np = normalize_params('monitor_mode' => false)
-    assert_equal false, np['monitor_mode']
-  end
-  def test_string__singleton
-    val = "This String"
-    def val.hello; end
-    assert_equal "This String", normalize_params(val)
-    assert val.respond_to?(:hello)
-    assert !normalize_params(val).respond_to?(:hello)
-  end
-  class MyString < String; end
-  def test_kind_of_string
-    s = MyString.new "This is a string"
-    assert_equal "This is a string", s.to_s
-    assert_equal MyString, s.class
-    assert_equal String, s.to_s.class
-    params = normalize_params(:val => [s])
-    assert_equal String, params[:val][0].class
-    assert_equal String, flatten(s).class
-    assert_equal String, truncate(s, 2).class
-  end
-  def test_number
-    normalize_params({ 'one' => 1.0, 'two' => '2'})
-  end
-  def test_nil
-    np = normalize_params({ nil => 1.0, 'two' => nil})
-    assert_equal "1.0", np['']
-    assert_equal nil, np['two']
-  end
-  def test_hash
-    val = ('A'..'Z').to_a.join * 100
-    assert_equal Hash[(val[0..63] + "...") => (("0"*16384) + "...")], normalize_params({ val => '0' * (16384*2) })
-  end
-  class MyHash < Hash
-
-  end
-  # Test to ensure that hash subclasses are properly converted
-  def test_hash_subclass
-    h = MyHash.new
-    h[:mine] = 'mine'
-    custom_params = { :one => {:hash => { :a => :b}, :myhash => h }}
-    nh = normalize_params(custom_params)
-    myhash = custom_params[:one][:myhash]
-    assert_equal MyHash, myhash.class
-    myhash = nh[:one][:myhash]
-    assert_equal Hash, myhash.class
-  end
-
-
-
-  def test_enumerable
-    e = MyEnumerable.new
-    custom_params = { :one => {:hash => { :a => :b}, :myenum => e }}
-    nh = normalize_params(custom_params)
-    myenum = nh[:one][:myenum]
-    assert_match(/MyEnumerable/, myenum)
-  end
-
-  def test_stringio
-    # Verify StringIO works like this normally:
-    s = StringIO.new "start" + ("foo bar bat " * 1000)
-    val = nil
-    s.each { | entry | val = entry; break }
-    assert_match(/^startfoo bar/, val)
-
-    # make sure stringios aren't affected by calling normalize_params:
-    s = StringIO.new "start" + ("foo bar bat " * 1000)
-    normalize_params({ :foo => s.string })
-    s.each { | entry | val = entry; break }
-    assert_match(/^startfoo bar/, val)
-  end
-  class MyEnumerable
-    include Enumerable
-
-    def each
-      yield "1"
-    end
-  end
-
-  def test_object
-    assert_equal ["foo", '#<OpenStruct>'], normalize_params(['foo', OpenStruct.new('z'=>'q')])
-  end
-
-  def test_strip_backtrace
-    clean_trace = strip_nr_from_backtrace(mock_backtrace)
-    assert_equal(0, clean_trace.grep(/newrelic_rpm/).size,
-                 "should remove all instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
-    assert_equal(0, clean_trace.grep(/trace/).size,
-                     "should 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: \n#{clean_trace.join("\n")}")
-  end
-
-  def test_disabled_strip_backtrace
-    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")}")
-    end
-  end
-
-  private
-  def mock_backtrace
-    [
-   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1620:in `find_one_without_trace'},
-   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1620:in `find_one'},
-   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1603:in `find_from_ids'},
-   %q{./test/new_relic/collection_helper_test.rb:112:in `test_strip_stackdump'},
-   %q{/home/app/gems/mocha-0.9.8/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb:19:in `__send__'},
-   %q{/home/app/gems/mocha-0.9.8/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb:19:in `run'},
-   %q{/home/app/test/unit/testsuite.rb:34:in `run'},
-   %q{/home/app/test/unit/testsuite.rb:33:in `each'},
-   %q{/home/app/test/unit/testsuite.rb:33:in `run'},
-   %q{/home/app/test/unit/testsuite.rb:34:in `run'},
-   %q{/home/app/test/unit/testsuite.rb:33:in `each'},
-   %q{/home/app/test/unit/testsuite.rb:33:in `run'},
-   %q{/home/app/test/unit/ui/testrunnermediator.rb:46:in `run_suite'}
-   ]
-  end
-end

data/test/new_relic/control/class_methods_test.rb

@@ -1,48 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
-require 'new_relic/control/class_methods'
-
-class BaseClassMethods
-  # stub class to enable testing of the module
-  include NewRelic::Control::ClassMethods
-end
-
-class NewRelic::Control::ClassMethodsTest < Minitest::Test
-  def setup
-    @base = ::BaseClassMethods.new
-    super
-  end
-
-  def test_instance
-    assert_equal(nil, @base.instance_variable_get('@instance'), 'instance should start out nil')
-    @base.expects(:new_instance).returns('a new instance')
-    assert_equal('a new instance', @base.instance, "should return the result from the #new_instance call")
-  end
-
-  def test_load_test_framework
-    local_env = mock('local env')
-    # a loose requirement here because the tests will *all* break if
-    # this does not work.
-    NewRelic::Control::Frameworks::Test.expects(:new).with(local_env, instance_of(String))
-    @base.expects(:local_env).returns(local_env)
-    @base.load_test_framework
-  end
-
-  def test_load_framework_class_existing
-    %w[rails rails3 sinatra ruby merb external].each do |type|
-      @base.load_framework_class(type)
-    end
-  end
-
-  def test_load_framework_class_missing
-    # this is used to allow other people to insert frameworks without
-    # having the file in our agent, i.e. define your own
-    # NewRelic::Control::Framework::FooBar
-    assert_raises(NameError) do
-      @base.load_framework_class('missing')
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'/../../../test_helper'))
-
-class NewRelic::Control::Frameworks::RailsTest < Minitest::Test
-  def test_install_browser_monitoring
-    require '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/instance_methods_test.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
-require 'new_relic/control/instance_methods'
-require 'new_relic/agent/configuration/yaml_source'
-
-class TestClass
-  include NewRelic::Control::InstanceMethods
-end
-
-class NewRelic::Control::InstanceMethodsTest < Minitest::Test
-  def setup
-    NewRelic::Agent.config.reset_to_defaults
-    @test = ::TestClass.new(nil)
-  end
-
-  def test_configure_agent_adds_the_yaml_config
-    refute_has_config NewRelic::Agent::Configuration::YamlSource
-    @test.configure_agent('test', {})
-    assert_has_config NewRelic::Agent::Configuration::YamlSource
-  end
-
-  def test_configure_agent_adds_the_manual_config
-    refute_has_config NewRelic::Agent::Configuration::ManualSource
-    @test.configure_agent('test', {})
-    assert_has_config NewRelic::Agent::Configuration::ManualSource
-  end
-
-  def test_no_high_security_config_by_default
-    refute_has_config NewRelic::Agent::Configuration::HighSecuritySource
-    @test.configure_agent('test', {:high_security => false})
-    refute_has_config NewRelic::Agent::Configuration::HighSecuritySource
-  end
-
-  def test_high_security_config_added_if_requested
-    refute_has_config NewRelic::Agent::Configuration::HighSecuritySource
-    @test.configure_agent('test', {:high_security => true})
-    assert_has_config NewRelic::Agent::Configuration::HighSecuritySource
-  end
-
-  def refute_has_config(clazz)
-    refute NewRelic::Agent.config.config_classes_for_testing.include? clazz
-  end
-
-  def assert_has_config(clazz)
-    assert NewRelic::Agent.config.config_classes_for_testing.include? clazz
-  end
-end

data/test/new_relic/control/instrumentation_test.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
-require 'new_relic/control/instrumentation'
-
-class InstrumentationTestClass
-  include NewRelic::Control::Instrumentation
-
-  def initialize
-    @instrumentation_files = []
-  end
-end
-
-class NewRelic::Control::InstrumentationTest < Minitest::Test
-  def setup
-    @test_class = InstrumentationTestClass.new
-  end
-
-  def test_load_instrumentation_files_logs_errors_during_require
-    @test_class.stubs(:require).raises('Instrumentation Test Error')
-    expects_logging(:warn, includes("Error loading"), any_parameters)
-    @test_class.load_instrumentation_files '*'
-  end
-
-  def test_add_instrumentation_loads_the_instrumentation_files_if_instrumented
-    pattern = 'Instrumentation test pattern'
-    @test_class.instance_eval { @instrumented = true }
-    @test_class.expects(:load_instrumentation_files).with(pattern).once
-    @test_class.add_instrumentation(pattern)
-  end
-
-  def test_add_instrumentation_adds_pattern_to_instrumentation_files_if_uninstrumented
-    expected_pattern = 'Instrumentation test pattern'
-    @test_class.instance_eval { @instrumented = false }
-    @test_class.add_instrumentation(expected_pattern)
-    result = @test_class.instance_variable_get(:@instrumentation_files)
-    assert_equal [expected_pattern], result
-  end
-
-  def test_install_shim_logs_if_instrumentation_has_already_been_installed
-    @test_class.instance_eval { @instrumented = true }
-    expects_logging(:error, includes('Cannot install'))
-    @test_class.install_shim
-  end
-
-  def test_install_shim_does_not_set_agent_if_already_instrumented
-    fake_shim = "Instrumentation Test Shim Agent"
-    @test_class.instance_eval { @instrumented = true }
-    NewRelic::Agent::ShimAgent.class_eval { @instance = fake_shim }
-
-    @test_class.install_shim
-    refute_equal NewRelic::Agent.agent, fake_shim
-  end
-end

data/test/new_relic/control_test.rb

@@ -1,232 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
-
-class NewRelic::ControlTest < Minitest::Test
-  attr_reader :control
-
-  def setup
-    @control =  NewRelic::Control.instance
-    raise 'oh geez, wrong class' unless NewRelic::Control.instance.is_a?(::NewRelic::Control::Frameworks::Test)
-    NewRelic::Agent.config.reset_to_defaults
-  end
-
-  def shutdown
-    NewRelic::Agent.shutdown
-  end
-
-  def test_settings_accessor
-    refute_nil control.settings
-  end
-
-  def test_root
-    assert File.directory?(NewRelic::Control.newrelic_root), NewRelic::Control.newrelic_root
-    if defined?(Rails::VERSION)
-      assert File.directory?(File.join(NewRelic::Control.newrelic_root, "lib")), NewRelic::Control.newrelic_root +  "/lib"
-    end
-  end
-
-  def test_info
-    NewRelic::Agent.manual_start
-    if defined?(Rails::VERSION)
-      assert_match(/jdbc|postgres|mysql|sqlite/, NewRelic::EnvironmentReport.new["Database adapter"])
-    end
-  end
-
-  def test_resolve_ip_for_localhost
-    with_config(:ssl => false) do
-      assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
-    end
-  end
-
-  def test_resolve_ip_for_non_existent_domain
-    with_config(:ssl => false) do
-      Resolv.stubs(:getaddress).raises(Resolv::ResolvError)
-      IPSocket.stubs(:getaddress).raises(SocketError)
-      assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
-    end
-  end
-
-  def test_resolves_valid_ip
-    with_config(:ssl => false) do
-      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
-  end
-
-  def test_do_not_resolve_if_we_need_to_verify_a_cert
-    with_config(:ssl => false) do
-      assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
-    end
-    with_config(:ssl => 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'
-    end
-  end
-
-  def test_resolve_ip_with_broken_dns
-    # Here be dragons: disable the ruby DNS lookup methods we use so
-    # that it will actually fail to resolve.
-    old_resolv = Resolv
-    old_ipsocket = IPSocket
-    Object.instance_eval { remove_const :Resolv}
-    Object.instance_eval {remove_const:'IPSocket' }
-
-    with_config(:ssl => false) do
-      assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
-    end
-
-    Object.instance_eval {const_set('Resolv', old_resolv); const_set('IPSocket', old_ipsocket)}
-    # these are here to make sure that the constant tomfoolery above
-    # has not broket the system unduly
-    assert_equal old_resolv, Resolv
-    assert_equal old_ipsocket, IPSocket
-  end
-
-  def test_transaction_threshold__override
-    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
-    with_config(:'transaction_tracer.enabled' => false,
-                :developer_mode => false, :monitor_mode => true) do
-      assert(!NewRelic::Agent.instance.transaction_sampler.enabled?,
-             'transaction tracer enabled when config calls for disabled')
-    end
-  end
-
-  def test_sql_tracer_disabled
-    with_config(:'slow_sql.enabled' => false, :monitor_mode => true) do
-      assert(!NewRelic::Agent.instance.sql_sampler.enabled?,
-             'sql tracer enabled when config calls for disabled')
-    end
-  end
-
-  def test_sql_tracer_disabled_with_record_sql_false
-    with_config(:slow_sql => { :enabled => true, :record_sql => 'off' }) do
-      refute NewRelic::Agent.instance.sql_sampler.enabled?,
-             'sql tracer enabled when config calls for disabled'
-    end
-  end
-
-  def test_sql_tracer_disabled_when_tt_disabled
-    with_config(:'transaction_tracer.enabled' => false,
-                :'slow_sql.enabled' => true,
-                :developer_mode => false, :monitor_mode => true) do
-      refute NewRelic::Agent.instance.sql_sampler.enabled?,
-             'sql enabled when transaction tracer disabled'
-    end
-  end
-
-  def test_sql_tracer_disabled_when_tt_disabled_by_server
-    with_config_low_priority({
-                 :'slow_sql.enabled'           => true,
-                 :'transaction_tracer.enabled' => true,
-                 :monitor_mode                 => true}) do
-      NewRelic::Agent.instance.finish_setup('collect_traces' => false)
-
-      refute NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-             'sql enabled when tracing disabled by server'
-    end
-  end
-
-  def test_init_plugin_loads_samplers_enabled
-    reset_agent
-
-    with_config(:disable_samplers       => false,
-                :disable_harvest_thread => true,
-                :agent_enabled          => true,
-                :monitor_mode           => true,
-                :license_key            => 'a'*40) do
-      NewRelic::Control.instance.init_plugin
-      assert NewRelic::Agent.instance.harvest_samplers.any?
-    end
-  end
-
-  def test_init_plugin_loads_samplers_disabled
-    reset_agent
-
-    with_config(:disable_samplers       => true,
-                :disable_harvest_thread => true,
-                :agent_enabled          => true,
-                :monitor_mode           => true,
-                :license_key            => 'a'*40) do
-      NewRelic::Control.instance.init_plugin
-      refute NewRelic::Agent.instance.harvest_samplers.any?
-    end
-  end
-
-  def test_agent_not_starting_does_not_load_samplers
-    reset_agent
-
-    NewRelic::Agent.instance.stubs(:defer_for_delayed_job?).returns(true)
-
-    with_config(:disable_samplers       => false,
-                :disable_harvest_thread => true,
-                :agent_enabled          => true,
-                :monitor_mode           => true,
-                :license_key            => 'a'*40) do
-      NewRelic::Control.instance.init_plugin
-      refute NewRelic::Agent.instance.already_started?
-      refute NewRelic::Agent.instance.harvest_samplers.any?
-    end
-  end
-
-  def test_agent_starting_after_fork_does_load_samplers
-    reset_agent
-
-    NewRelic::Agent.instance.stubs(:defer_for_delayed_job?).returns(true)
-
-    with_config(:disable_samplers       => false,
-                :disable_harvest_thread => true,
-                :agent_enabled          => true,
-                :monitor_mode           => true,
-                :license_key            => 'a'*40) do
-      NewRelic::Control.instance.init_plugin
-      NewRelic::Agent.instance.stubs(:defer_for_delayed_job?).returns(false)
-      NewRelic::Agent.after_fork
-      assert NewRelic::Agent.instance.already_started?
-      assert NewRelic::Agent.instance.harvest_samplers.any?
-    end
-  end
-
-  def reset_agent
-    NewRelic::Agent.shutdown
-    NewRelic::Agent.instance.harvest_samplers.clear
-    NewRelic::Agent.instance.instance_variable_set(:@connect_state, :pending)
-    NewRelic::Agent.instance.instance_variable_set(:@worker_thread, nil)
-    NewRelic::Agent.instance.harvester.instance_variable_set(:@starting_pid, nil)
-  end
-end