newrelic_rpm 4.1.0.333 → 4.2.0.334

data/test/new_relic/agent/configuration/dotted_hash_test.rb

@@ -1,53 +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'))
-
-module NewRelic::Agent::Configuration
-  class DottedHashTest < Minitest::Test
-    def test_without_nesting
-      hash = DottedHash.new({ :turtle => 1 })
-      assert_equal({ :turtle => 1 }, hash)
-    end
-
-    def test_with_nesting
-      hash = DottedHash.new({ :turtle => { :turtle => 1 } })
-      assert_equal({ :'turtle.turtle' => 1 }, hash)
-    end
-
-    def test_with_multiple_layers_of_nesting
-      hash = DottedHash.new({ :turtle => { :turtle => { :turtle => 1 } } })
-      assert_equal({ :'turtle.turtle.turtle' => 1 }, hash)
-    end
-
-    def test_turns_keys_to_symbols
-      hash = DottedHash.new({ "turtle" => { "turtle" => { "turtle" => 1 } } })
-      assert_equal({ :'turtle.turtle.turtle' => 1 }, hash)
-    end
-
-    def test_to_hash
-      dotted = DottedHash.new({ "turtle" => { "turtle" => { "turtle" => 1 } } })
-      hash = dotted.to_hash
-
-      assert_instance_of(Hash, hash)
-      assert_equal({ :'turtle.turtle.turtle' => 1 }, hash)
-    end
-
-    def test_option_to_keep_nesting
-      hash = DottedHash.new({ :turtle => { :turtle => 1 } }, true)
-      expected = {
-        :turtle => { :turtle => 1},
-        :'turtle.turtle' => 1,
-      }
-
-      assert_equal(expected, hash)
-    end
-
-    def test_borks_with_non_symbolizing_key
-      assert_raises(NoMethodError) do
-        DottedHash.new({ Object.new => 2 }, true)
-      end
-    end
-  end
-end

data/test/new_relic/agent/configuration/environment_source_test.rb

@@ -1,201 +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/agent/configuration/environment_source'
-
-module NewRelic::Agent::Configuration
-  class EnvironmentSourceTest < Minitest::Test
-
-    def setup
-      @original_env = {}
-      @original_env.replace(ENV)
-      @environment_source = EnvironmentSource.new
-    end
-
-    def teardown
-      ENV.replace(@original_env)
-    end
-
-    def test_environment_strings_are_applied
-      assert_applied_string 'NRCONFIG', 'config_path'
-      assert_applied_string 'NEW_RELIC_LICENSE_KEY', 'license_key'
-      assert_applied_string 'NEWRELIC_LICENSE_KEY', 'license_key'
-      assert_applied_string 'NEW_RELIC_APP_NAME', 'app_name'
-      assert_applied_string 'NEWRELIC_APP_NAME', 'app_name'
-      assert_applied_string 'NEW_RELIC_HOST', 'host'
-    end
-
-    def test_environment_fixnums_are_applied
-      assert_applied_fixnum 'NEW_RELIC_PORT', 'port'
-    end
-
-    def test_environment_symbols_are_applied
-      assert_applied_symbol 'NEW_RELIC_DISPATCHER', 'dispatcher'
-      assert_applied_symbol 'NEWRELIC_DISPATCHER', 'dispatcher'
-      assert_applied_symbol 'NEW_RELIC_FRAMEWORK', 'framework'
-      assert_applied_symbol 'NEWRELIC_FRAMEWORK', 'framework'
-    end
-
-    %w| NEWRELIC_ENABLE NEWRELIC_ENABLED NEW_RELIC_ENABLE NEW_RELIC_ENABLED |.each do |var|
-      define_method("test_environment_booleans_truths_are_applied_to_#{var}") do
-        ENV[var] = 'true'
-        assert EnvironmentSource.new[:enabled]
-        ENV[var] = 'on'
-        assert EnvironmentSource.new[:enabled]
-        ENV[var] = 'yes'
-        assert EnvironmentSource.new[:enabled]
-        ENV.delete(var)
-      end
-
-      define_method("test_environment_booleans_falsehoods_are_applied_to_#{var}") do
-        ENV[var] = 'false'
-        assert !EnvironmentSource.new[:enabled]
-        ENV[var] = 'off'
-        assert !EnvironmentSource.new[:enabled]
-        ENV[var] = 'no'
-        assert !EnvironmentSource.new[:enabled]
-        ENV.delete(var)
-      end
-    end
-
-    %w| NEWRELIC_DISABLE_HARVEST_THREAD NEW_RELIC_DISABLE_HARVEST_THREAD |.each do |var|
-      define_method("test_environment_booleans_truths_are_applied_to_#{var}") do
-        ENV[var] = 'true'
-        assert EnvironmentSource.new[:disable_harvest_thread]
-        ENV[var] = 'on'
-        assert EnvironmentSource.new[:disable_harvest_thread]
-        ENV[var] = 'yes'
-        assert EnvironmentSource.new[:disable_harvest_thread]
-        ENV.delete(var)
-      end
-
-      define_method("test_environment_booleans_falsehoods_are_applied_to_#{var}") do
-        ENV[var] = 'false'
-        assert !EnvironmentSource.new[:disable_harvest_thread]
-        ENV[var] = 'off'
-        assert !EnvironmentSource.new[:disable_harvest_thread]
-        ENV[var] = 'no'
-        assert !EnvironmentSource.new[:disable_harvest_thread]
-        ENV.delete(var)
-      end
-    end
-
-    def test_set_log_config_from_environment
-      ENV['NEW_RELIC_LOG'] = 'off/in/space.log'
-      source = EnvironmentSource.new
-      assert_equal 'off/in', source[:log_file_path]
-      assert_equal 'space.log', source[:log_file_name]
-    end
-
-    def test_set_log_config_STDOUT_from_environment
-      ENV['NEW_RELIC_LOG'] = 'STDOUT'
-      source = EnvironmentSource.new
-      assert_equal 'STDOUT', source[:log_file_name]
-      assert_equal 'STDOUT', source[:log_file_path]
-    end
-
-    def test_set_values_from_new_relic_environment_variables
-      keys = %w(NEW_RELIC_LICENSE_KEY NEWRELIC_CONFIG_PATH)
-      keys.each { |key| ENV[key] = 'skywizards' }
-
-      expected_source = EnvironmentSource.new
-
-      [:license_key, :config_path].each do |key|
-        assert_equal 'skywizards', expected_source[key]
-      end
-    end
-
-    def test_set_values_from_new_relic_environment_variables_warns_unknowns
-      ENV['NEWRELIC_DOESNT_USE_THIS_VALUE'] = "true"
-      expects_logging(:info, includes("NEWRELIC_DOESNT_USE_THIS_VALUE"))
-      @environment_source.set_values_from_new_relic_environment_variables
-    end
-
-    def test_set_values_from_new_relic_environment_variables_ignores_NEW_RELIC_LOG
-      ENV['NEW_RELIC_LOG'] = "STDOUT"
-      expects_no_logging(:info)
-      @environment_source.set_values_from_new_relic_environment_variables
-    end
-
-    def test_set_value_from_environment_variable
-      ENV['NEW_RELIC_LICENSE_KEY'] = 'super rad'
-      @environment_source.set_value_from_environment_variable('NEW_RELIC_LICENSE_KEY')
-      assert_equal @environment_source[:license_key], 'super rad'
-    end
-
-    def test_set_key_by_type_uses_the_default_type
-      ENV['NEW_RELIC_TEST'] = 'true'
-      @environment_source.set_key_by_type(:enabled, 'NEW_RELIC_TEST')
-      assert_equal true, @environment_source[:enabled]
-    end
-
-    def test_set_key_with_new_relic_prefix
-      assert_applied_string('NEW_RELIC_LICENSE_KEY', :license_key)
-    end
-
-    def test_set_key_with_newrelic_prefix
-      assert_applied_string('NEWRELIC_LICENSE_KEY', :license_key)
-    end
-
-    def test_does_not_set_key_without_new_relic_related_prefix
-      ENV['CONFIG_PATH'] = 'boom'
-      refute_equal 'boom', EnvironmentSource.new[:config_path]
-    end
-
-    def test_convert_environment_key_to_config_key
-      result = @environment_source.convert_environment_key_to_config_key('NEW_RELIC_IS_RAD')
-      assert_equal :is_rad, result
-    end
-
-    def test_convert_environment_key_to_config_key_respects_aliases
-      assert_applied_boolean('NEWRELIC_ENABLE', :enabled)
-    end
-
-    def test_convert_environment_key_to_config_key_allows_underscores_as_dots
-      assert_applied_string('NEW_RELIC_AUDIT_LOG_PATH', :'audit_log.path')
-    end
-
-    def test_collect_new_relic_environment_variable_keys
-      keys = %w(NEW_RELIC_IS_RAD NEWRELIC_IS_MAGIC)
-      keys.each { |key| ENV[key] = 'true' }
-
-      result = @environment_source.collect_new_relic_environment_variable_keys
-      assert_equal keys, result
-    end
-
-    def test_does_not_warn_for_new_relic_env_environment_variable
-      expects_no_logging(:warn)
-      expects_no_logging(:info)
-      with_environment('NEW_RELIC_ENV' => 'foo') do
-        @environment_source.set_values_from_new_relic_environment_variables
-      end
-    end
-
-    def assert_applied_string(env_var, config_var)
-      ENV[env_var] = 'test value'
-      assert_equal 'test value', EnvironmentSource.new[config_var.to_sym]
-      ENV.delete(env_var)
-    end
-
-    def assert_applied_symbol(env_var, config_var)
-      ENV[env_var] = 'test value'
-      assert_equal :'test value', EnvironmentSource.new[config_var.to_sym]
-      ENV.delete(env_var)
-    end
-
-    def assert_applied_fixnum(env_var, config_var)
-      ENV[env_var] = '3000'
-      assert_equal 3000, EnvironmentSource.new[config_var.to_sym]
-      ENV.delete(env_var)
-    end
-
-    def assert_applied_boolean(env_var, config_var)
-      ENV[env_var] = 'true'
-      assert_equal true, EnvironmentSource.new[config_var.to_sym]
-      ENV.delete(env_var)
-    end
-
-  end
-end

data/test/new_relic/agent/configuration/high_security_source_test.rb

@@ -1,92 +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/agent/configuration/high_security_source'
-
-module NewRelic::Agent::Configuration
-  class HighSecuritySourceTest < Minitest::Test
-    def test_leaves_obfuscated_record_sql_parameters
-      local_settings = {
-        :'transaction_tracer.record_sql' => 'obfuscated',
-        :'slow_sql.record_sql'           => 'obfuscated'
-      }
-
-      source = HighSecuritySource.new(local_settings)
-
-      assert_equal('obfuscated', source[:'transaction_tracer.record_sql'])
-      assert_equal('obfuscated', source[:'slow_sql.record_sql'])
-    end
-
-    def test_leaves_off_record_sql_parameters
-      local_settings = {
-        :'transaction_tracer.record_sql' => 'off',
-        :'slow_sql.record_sql'           => 'off'
-      }
-
-      source = HighSecuritySource.new(local_settings)
-
-      assert_equal('off', source[:'transaction_tracer.record_sql'])
-      assert_equal('off', source[:'slow_sql.record_sql'])
-    end
-
-    def test_changes_raw_record_sql_to_obfuscated
-      local_settings = {
-        :'transaction_tracer.record_sql' => 'raw',
-        :'slow_sql.record_sql'           => 'raw'
-      }
-
-      source = HighSecuritySource.new(local_settings)
-
-      assert_equal('obfuscated', source[:'transaction_tracer.record_sql'])
-      assert_equal('obfuscated', source[:'slow_sql.record_sql'])
-    end
-
-    def test_forces_unrecognized_values_to_off
-      local_settings = {
-        :'transaction_tracer.record_sql' => 'jibberish',
-        :'slow_sql.record_sql'           => 'junk'
-      }
-
-      expects_logging(:info, includes('jibberish'))
-
-      source = HighSecuritySource.new(local_settings)
-
-      assert_equal('off', source[:'transaction_tracer.record_sql'])
-      assert_equal('off', source[:'slow_sql.record_sql'])
-    end
-
-    def test_logs_when_changing_raw_to_obfuscated
-      local_settings = {
-        :'transaction_tracer.record_sql' => 'raw',
-        :'slow_sql.record_sql'           => 'raw'
-      }
-
-      expects_logging(:info, all_of(includes('raw'), includes('obfuscated')))
-
-      HighSecuritySource.new(local_settings)
-    end
-
-    def test_no_logging_when_allowed_values
-      local_settings = {
-        :'transaction_tracer.record_sql' => 'off',
-        :'slow_sql.record_sql'           => 'obfuscated'
-      }
-
-      expects_no_logging(:info)
-
-      HighSecuritySource.new(local_settings)
-    end
-
-    def test_forces_redis_argument_recording_off
-      local_settings = {
-        :'transaction_tracer.record_redis_arguments' => true
-      }
-
-      source = HighSecuritySource.new(local_settings)
-
-      assert_equal(false, source[:'transaction_tracer.record_redis_arguments'])
-    end
-  end
-end

data/test/new_relic/agent/configuration/manager_test.rb

@@ -1,455 +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/agent/configuration/manager'
-require 'new_relic/agent/configuration/mask_defaults'
-require 'new_relic/agent/threading/backtrace_service'
-
-module NewRelic::Agent::Configuration
-  class ManagerTest < Minitest::Test
-    def setup
-      # Defaults look up against the shared config, so reset and use it
-      NewRelic::Agent.reset_config
-      @manager = NewRelic::Agent.config
-    end
-
-    def teardown
-      @manager.reset_to_defaults
-    end
-
-    def test_should_use_indifferent_access
-      config = NewRelic::Agent::Configuration::DottedHash.new('string' => 'string', :symbol => 'symbol')
-      @manager.add_config_for_testing(config)
-      assert_equal 'string', @manager[:string]
-      assert_equal 'symbol', @manager['symbol']
-    end
-
-    def test_should_apply_config_sources_in_order
-      config0 = {
-        :foo => 'default foo',
-        :bar => 'default bar',
-        :baz => 'default baz'
-      }
-      @manager.add_config_for_testing(config0, false)
-      config1 = { :foo => 'wrong foo', :bar => 'real bar' }
-      @manager.add_config_for_testing(config1)
-      config2 = { :foo => 'real foo' }
-      @manager.add_config_for_testing(config2)
-
-      assert_equal 'real foo'   , @manager['foo']
-      assert_equal 'real bar'   , @manager['bar']
-      assert_equal 'default baz', @manager['baz']
-    end
-
-    def test_sources_applied_in_correct_order
-      # in order of precedence
-      high_security = HighSecuritySource.new({})
-      server_source = ServerSource.new('data_report_period' => 3, 'capture_params' => true)
-      manual_source = ManualSource.new(:data_report_period  => 2, :bar => 'bar', :capture_params => true)
-
-      # load them out of order, just to prove that load order
-      # doesn't determine precedence
-      @manager.replace_or_add_config(manual_source)
-      @manager.replace_or_add_config(server_source)
-      @manager.replace_or_add_config(high_security)
-
-      assert_equal 3,     @manager['data_report_period']
-      assert_equal 'bar', @manager['bar']
-      assert_equal false, @manager['capture_params']
-    end
-
-    def test_identifying_config_source
-      hash_source = {:foo => 'foo', :bar => 'default'}
-      @manager.add_config_for_testing(hash_source, false)
-      test_source = ManualSource.new(:bar => 'bar', :baz => 'baz')
-      @manager.replace_or_add_config(test_source)
-
-      refute_equal test_source, @manager.source(:foo)
-      assert_equal test_source, @manager.source(:bar)
-      assert_equal test_source, @manager.source(:baz)
-    end
-
-    def test_callable_value_for_config_should_return_computed_value
-      source = {
-        :foo          => 'bar',
-        :simple_value => Proc.new { '666' },
-        :reference    => Proc.new { self['foo'] }
-      }
-      @manager.add_config_for_testing(source)
-
-      assert_equal 'bar', @manager[:foo]
-      assert_equal '666', @manager[:simple_value]
-      assert_equal 'bar', @manager[:reference]
-    end
-
-    def test_manager_resolves_nested_procs_from_default_source
-      source = {
-        :foo    => Proc.new { self[:bar] },
-        :bar    => Proc.new { self[:baz] },
-        :baz    => Proc.new { 'Russian Nesting Dolls!' }
-      }
-      @manager.add_config_for_testing(source)
-
-      source.keys.each do |key|
-        assert_equal 'Russian Nesting Dolls!', @manager[key]
-      end
-    end
-
-    def test_should_not_apply_removed_sources
-      test_source = { :test_config_accessor => true }
-      @manager.add_config_for_testing(test_source)
-      @manager.remove_config(test_source)
-
-      assert_equal nil, @manager['test_config_accessor']
-    end
-
-    def test_should_read_license_key_from_env
-      ENV['NEWRELIC_LICENSE_KEY'] = 'right'
-      manager = NewRelic::Agent::Configuration::Manager.new
-      manager.add_config_for_testing({:license_key => 'wrong'}, false)
-
-      assert_equal 'right', manager['license_key']
-    ensure
-      ENV.delete('NEWRELIC_LICENSE_KEY')
-    end
-
-    def test_config_values_should_be_memoized
-      @manager.add_config_for_testing(:setting => 'correct value')
-      assert_equal 'correct value', @manager[:setting]
-
-      @manager.instance_variable_get(:@configs_for_testing).
-               unshift(:setting => 'wrong value')
-
-      assert_equal 'correct value', @manager[:setting]
-    end
-
-    def test_dotted_hash_to_hash_is_plain_hash
-      dotted = NewRelic::Agent::Configuration::DottedHash.new({})
-      assert_equal(::Hash, dotted.to_hash.class)
-    end
-
-    def test_to_collector_hash
-      @manager.delete_all_configs_for_testing
-      @manager.add_config_for_testing(:eins => Proc.new { self[:one] })
-      @manager.add_config_for_testing(:one => 1)
-      @manager.add_config_for_testing(:two => 2)
-      @manager.add_config_for_testing(:nested => {:madness => 'test'})
-      @manager.add_config_for_testing(:'nested.madness' => 'test')
-
-      assert_equal({ :eins => 1, :one => 1, :two => 2, :'nested.madness' => 'test' },
-                   @manager.to_collector_hash)
-    end
-
-    # Necessary to keep the pruby marshaller happy
-    def test_to_collector_hash_returns_bare_hash
-      @manager.delete_all_configs_for_testing
-      @manager.add_config_for_testing(:eins => Proc.new { self[:one] })
-
-      assert_equal(::Hash, @manager.to_collector_hash.class)
-    end
-
-    def test_to_collector_hash_scrubs_private_settings
-      @manager.delete_all_configs_for_testing
-      @manager.add_config_for_testing(:proxy_user => 'user')
-      @manager.add_config_for_testing(:proxy_pass => 'password')
-      @manager.add_config_for_testing(:one => 1)
-      @manager.add_config_for_testing(:two => 2)
-
-      assert_equal({ :one => 1, :two => 2 }, @manager.to_collector_hash)
-    end
-
-    def test_config_masks
-      NewRelic::Agent::Configuration::MASK_DEFAULTS[:boo] = Proc.new { true }
-
-      @manager.add_config_for_testing(:boo => 1)
-
-      assert_equal false, @manager.to_collector_hash.has_key?(:boo)
-    end
-
-    def test_config_masks_conditionally
-      NewRelic::Agent::Configuration::MASK_DEFAULTS[:boo] = Proc.new { false }
-
-      @manager.add_config_for_testing(:boo => 1)
-
-      assert @manager.to_collector_hash.has_key?(:boo)
-    end
-
-    def test_config_masks_thread_profiler
-      supported = NewRelic::Agent::Threading::BacktraceService.is_supported?
-      reported_config = @manager.to_collector_hash
-
-      if supported
-        refute_nil reported_config[:'thread_profiler.enabled']
-      else
-        assert_equal nil, reported_config[:'thread_profiler.enabled']
-      end
-    end
-
-    def test_replacing_a_layer_by_class
-      old_config = NewRelic::Agent::Configuration::ManualSource.new(:test => 'wrong')
-      @manager.replace_or_add_config(old_config)
-      new_config = NewRelic::Agent::Configuration::ManualSource.new(:test => 'right')
-      @manager.replace_or_add_config(new_config)
-
-      assert_equal 'right', @manager[:test]
-      assert_equal 3, @manager.num_configs_for_testing
-    end
-
-    def test_registering_a_callback
-      observed_value = 'old'
-      @manager.add_config_for_testing(:test => 'original')
-
-      @manager.register_callback(:test) do |value|
-        observed_value = value
-      end
-      assert_equal 'original', observed_value
-
-      @manager.add_config_for_testing(:test => 'new')
-      assert_equal 'new', observed_value
-    end
-
-    def test_callback_not_called_if_no_change
-      state = nil
-      @manager.add_config_for_testing(:test => true, :other => false)
-      @manager.register_callback(:test) do |value|
-        state = 'wrong'
-      end
-      state = 'right'
-      config = {:test => true}
-      @manager.add_config_for_testing(config)
-      @manager.remove_config(config)
-
-      assert_equal 'right', state
-    end
-
-    def test_finished_configuring
-      @manager.add_config_for_testing(:layer => "yo")
-      assert_equal false, @manager.finished_configuring?
-
-      @manager.replace_or_add_config(ServerSource.new({}))
-      assert_equal true, @manager.finished_configuring?
-    end
-
-    def test_notifies_finished_configuring
-      called = false
-      NewRelic::Agent.instance.events.subscribe(:finished_configuring) { called = true }
-      @manager.replace_or_add_config(ServerSource.new({}))
-
-      assert_equal true, called
-    end
-
-    def test_doesnt_notify_unless_finished
-      called = false
-      NewRelic::Agent.instance.events.subscribe(:finished_configuring) { called = true }
-
-      @manager.add_config_for_testing(:fake => "config")
-      @manager.replace_or_add_config(ManualSource.new(:manual => true))
-      @manager.replace_or_add_config(YamlSource.new("", "test"))
-
-      assert_equal false, called
-    end
-
-    def test_high_security_enables_strip_exception_messages
-      @manager.add_config_for_testing(:high_security => true)
-
-      assert_truthy @manager[:'strip_exception_messages.enabled']
-    end
-
-    def test_stripped_exceptions_whitelist_contains_only_valid_exception_classes
-      @manager.add_config_for_testing(:'strip_exception_messages.whitelist' => 'LocalJumpError, NonExistentException')
-      assert_equal [LocalJumpError], @manager[:'strip_exception_messages.whitelist']
-    end
-
-    def test_should_log_when_applying
-      log = with_array_logger(:debug) do
-        @manager.add_config_for_testing(:test => "asdf")
-      end
-
-      log_lines = log.array
-      assert_match(/DEBUG.*asdf/, log_lines[0])
-    end
-
-    def test_should_log_when_removing
-      config = { :test => "asdf" }
-      @manager.add_config_for_testing(config)
-
-      log = with_array_logger(:debug) do
-        @manager.remove_config(config)
-      end
-
-      log_lines = log.array
-      refute_match(/DEBUG.*asdf/, log_lines[0])
-    end
-
-    def test_config_is_correctly_initialized
-      assert @manager.config_classes_for_testing.include?(EnvironmentSource)
-      assert @manager.config_classes_for_testing.include?(DefaultSource)
-      refute @manager.config_classes_for_testing.include?(ManualSource)
-      refute @manager.config_classes_for_testing.include?(ServerSource)
-      refute @manager.config_classes_for_testing.include?(YamlSource)
-      refute @manager.config_classes_for_testing.include?(HighSecuritySource)
-    end
-
-    load_cross_agent_test("labels").each do |testcase|
-      define_method("test_#{testcase['name']}") do
-        @manager.add_config_for_testing(:labels => testcase["labelString"])
-
-        assert_warning if testcase["warning"]
-        assert_equal(testcase["expected"].sort_by { |h| h["label_type"] },
-                     @manager.parse_labels_from_string.sort_by { |h| h["label_type"] },
-                     "failed on #{testcase["name"]}")
-      end
-    end
-
-    def test_parse_labels_from_dictionary_with_hard_failure
-      bad_label_object = Object.new
-      @manager.add_config_for_testing(:labels => bad_label_object)
-
-      assert_parsing_error
-      assert_parsed_labels([])
-    end
-
-    def test_parse_labels_from_string_with_hard_failure
-      bad_string = "baaaad"
-      bad_string.stubs(:strip).raises("Booom")
-      @manager.add_config_for_testing(:labels => bad_string)
-
-      assert_parsing_error
-      assert_parsed_labels([])
-    end
-
-    def test_parse_labels_from_dictionary
-      @manager.add_config_for_testing(:labels => { 'Server' => 'East', 'Data Center' => 'North' })
-
-      assert_parsed_labels([
-        { 'label_type' => 'Server', 'label_value' => 'East' },
-        { 'label_type' => 'Data Center', 'label_value' => 'North' }
-      ])
-    end
-
-    def test_parse_labels_from_dictionary_applies_length_limits
-      @manager.add_config_for_testing(:labels => { 'K' * 256 => 'V' * 256 })
-      expected = [ { 'label_type' => 'K' * 255, 'label_value' => 'V' * 255 } ]
-
-      expects_logging(:warn, includes("truncated"))
-      assert_parsed_labels(expected)
-    end
-
-    def test_parse_labels_from_dictionary_disallows_further_nested_hashes
-      @manager.add_config_for_testing(:labels => {
-        "More Nesting" => { "Hahaha" => "Ha" }
-      })
-
-      assert_warning
-      assert_parsed_labels([])
-    end
-
-    def test_parse_labels_from_dictionary_allows_numerics
-      @manager.add_config_for_testing(:labels => {
-        "the answer" => 42
-      })
-
-      expected = [{ 'label_type' => 'the answer', 'label_value' => '42' }]
-      assert_parsed_labels(expected)
-    end
-
-    def test_parse_labels_from_dictionary_allows_booleans
-      @manager.add_config_for_testing(:labels => {
-        "truthy" => true,
-        "falsy"  => false
-      })
-
-      expected = [
-        { 'label_type' => 'truthy', 'label_value' => 'true' },
-        { 'label_type' => 'falsy',  'label_value' => 'false' }
-      ]
-      assert_parsed_labels(expected)
-    end
-
-    def test_apply_transformations
-      transform = Proc.new { |value| value.gsub('foo', 'baz') }
-      ::NewRelic::Agent::Configuration::DefaultSource.stubs(:transform_for).returns(transform)
-
-      assert_equal 'bazbar', @manager.apply_transformations(:test, 'foobar')
-    end
-
-    def test_fetch_with_a_transform_returns_the_transformed_value
-      with_config(:rules => { :ignore_url_regexes => ['more than meets the eye'] }) do
-        assert_equal [/more than meets the eye/], @manager.fetch(:'rules.ignore_url_regexes')
-      end
-    end
-
-    def test_fetch_skips_the_config_layer_if_transformation_raises_error
-      bomb = Proc.new do |value|
-        if value == 'boom'
-          raise StandardError.new
-        else
-          value
-        end
-      end
-      @manager.stubs(:transform_from_default).returns(bomb)
-
-      with_config(:'rules.ignore_url_regexes' => 'boom') do
-        assert_equal [], @manager.fetch(:'rules.ignore_url_regexes')
-      end
-    end
-
-    def test_default_to_value_of
-      with_config(:port => 8888) do
-        result = @manager.fetch(:api_port)
-        assert_equal 8888, result
-      end
-    end
-
-    def test_default_to_value_of_only_happens_at_defaults
-      with_config(:port => 8888, :api_port => 3000) do
-        result = @manager.fetch(:api_port)
-        assert_equal 3000, result
-      end
-    end
-
-    def test_evaluate_procs_returns_evaluated_value_if_it_responds_to_call
-      callable = Proc.new { 'test' }
-      assert_equal 'test', @manager.evaluate_procs(callable)
-    end
-
-    def test_evaluate_procs_returns_original_value_if_it_does_not_respond_to_call
-      assert_equal 'test', @manager.evaluate_procs('test')
-    end
-
-    def test_apply_transformations_logs_error_if_transformation_fails
-      bomb = Proc.new { raise StandardError.new }
-      @manager.stubs(:transform_from_default).returns(bomb)
-
-      expects_logging(:error, includes("Error applying transformation"), any_parameters)
-
-      assert_raises StandardError do
-        @manager.apply_transformations(:test_key, 'test_value')
-      end
-    end
-
-    def test_apply_transformations_reraises_errors
-      bomb = Proc.new { raise StandardError.new }
-      @manager.stubs(:transform_from_default).returns(bomb)
-
-      assert_raises StandardError do
-        @manager.apply_transformations(:test_key, 'test_value')
-      end
-    end
-
-    def assert_parsed_labels(expected)
-      result = @manager.parsed_labels
-      assert_equal expected, result
-    end
-
-    def assert_warning
-      expects_logging(:warn, any_parameters, any_parameters)
-    end
-
-    def assert_parsing_error
-      expects_logging(:error, includes(Manager::PARSING_LABELS_FAILURE), any_parameters)
-    end
-  end
-end