ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -1,26 +1,43 @@
 ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require "new_relic/agent/browser_monitoring"
+require "new_relic/rack/browser_monitoring"
+require 'ostruct'
 
 class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   include NewRelic::Agent::BrowserMonitoring
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-  
+
   def setup
     NewRelic::Agent.manual_start
-    @browser_monitoring_key = "fred"
+    @config = {
+      :beacon                 => 'beacon',
+      :disable_mobile_headers => false,
+      :browser_key            => 'browserKey',
+      :application_id         => 5,
+      :'rum.enabled'          => true,
+      :episodes_file          => 'this_is_my_file',
+      :'rum.jsonp'            => true
+    }
+    NewRelic::Agent.config.apply_config(@config)
     @episodes_file = "this_is_my_file"
     NewRelic::Agent.instance.instance_eval do
-      @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file", 'rum.jsonp' => true})
+      @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new
     end
+
+  def teardown
     Thread.current[:last_metric_frame] = nil
     NewRelic::Agent::TransactionInfo.clear
+    NewRelic::Agent.config.remove_config(@config)
   end
 
-  def teardown
     mocha_teardown
   end
 
+  def test_auto_instrumentation_config_defaults_to_enabled
+    assert NewRelic::Agent.config[:'browser_monitoring.auto_instrument']
+  end
+
   def test_browser_monitoring_start_time_is_reset_each_request_when_auto_instrument_is_disabled
     controller = Object.new
     def controller.perform_action_without_newrelic_trace(method, options={});
@@ -29,20 +46,21 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     def controller.newrelic_metric_path; "foo"; end
     controller.extend ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
     controller.extend ::NewRelic::Agent::BrowserMonitoring
-    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => false }
 
-    controller.perform_action_with_newrelic_trace(:index)
-    first_request_start_time = controller.send(:browser_monitoring_start_time)
-    controller.perform_action_with_newrelic_trace(:index)
-    second_request_start_time = controller.send(:browser_monitoring_start_time)
+    with_config(:'browser_monitoring.auto_instrument' => false) do
+      controller.perform_action_with_newrelic_trace(:index)
+      first_request_start_time = controller.send(:browser_monitoring_start_time)
+      controller.perform_action_with_newrelic_trace(:index)
+      second_request_start_time = controller.send(:browser_monitoring_start_time)
 
-    # assert that these aren't the same time object
-    # the start time should be reinitialized each request to the controller
-    assert !(first_request_start_time.equal? second_request_start_time)
+      # assert that these aren't the same time object
+      # the start time should be reinitialized each request to the controller
+      assert !(first_request_start_time.equal? second_request_start_time)
+    end
   end
 
   def test_browser_timing_header_with_no_beacon_configuration
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns( nil)
     header = browser_timing_header
     assert_equal "", header
   end
@@ -53,15 +71,17 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_timing_header_with_rum_enabled_not_specified
-    NewRelic::Agent.instance.expects(:beacon_configuration).at_least_once.returns( NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new)
     header = browser_timing_header
     assert_equal "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header
   end
 
   def test_browser_timing_header_with_rum_enabled_false
-    NewRelic::Agent.instance.expects(:beacon_configuration).twice.returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => false, "browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
-    header = browser_timing_header
-    assert_equal "", header
+    with_config(:'rum.enabled' => false) do
+      NewRelic::Agent.instance.stubs(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new)
+      header = browser_timing_header
+      assert_equal "", header
+    end
   end
 
   def test_browser_timing_header_disable_all_tracing
@@ -81,28 +101,34 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_timing_footer
-    browser_timing_header
-    NewRelic::Control.instance.expects(:license_key).returns("a" * 13)
-
-    footer = browser_timing_footer
-    snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
+    with_config(:license_key => 'a' * 13) do
+      browser_timing_header
+      footer = browser_timing_footer
+      snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
 var e=document.createElement("script");'
-    assert footer.include?(snippet), "Expected footer to include snippet: #{snippet}, but instead was #{footer}"
+      assert(footer.include?(snippet),
+             "Expected footer to include snippet: #{snippet}, but instead was #{footer}")
+    end
   end
 
   def test_browser_timing_footer_with_no_browser_key_rum_enabled
-    browser_timing_header
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
-    footer = browser_timing_footer
-    assert_equal "", footer
+    with_config(:browser_key => '') do
+      browser_timing_header
+      NewRelic::Agent.instance.stubs(:beacon_configuration).returns(NewRelic::Agent::BeaconConfiguration.new)
+      footer = browser_timing_footer
+      assert_equal "", footer
+    end
   end
 
   def test_browser_timing_footer_with_no_browser_key_rum_disabled
-    browser_timing_header
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => false, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
-    footer = browser_timing_footer
-    assert_equal "", footer
+    with_config(:'rum.enabled' => false) do
+      browser_timing_header
+      NewRelic::Agent.instance.stubs(:beacon_configuration) \
+        .returns(NewRelic::Agent::BeaconConfiguration.new)
+      footer = browser_timing_footer
+      assert_equal "", footer
+    end
   end
 
   def test_browser_timing_footer_with_rum_enabled_not_specified
@@ -110,26 +136,27 @@ var e=document.createElement("script");'
 
     license_bytes = [];
     ("a" * 13).each_byte {|byte| license_bytes << byte}
-    config =  NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file", "license_bytes" => license_bytes})
+    config =  NewRelic::Agent::BeaconConfiguration.new
     config.expects(:license_bytes).returns(license_bytes).at_least_once
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns(config).at_least_once
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns(config).at_least_once
     footer = browser_timing_footer
     beginning_snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
 var e=document.createElement("script");'
-    ending_snippet = "])</script>"
-    assert(footer.include?(beginning_snippet), "expected footer to include beginning snippet: #{beginning_snippet}, but was #{footer}")
-    assert(footer.include?(ending_snippet), "expected footer to include ending snippet: #{ending_snippet}, but was #{footer}")
+    ending_snippet = "]);</script>"
+    assert(footer.include?(beginning_snippet),
+           "expected footer to include beginning snippet: #{beginning_snippet}, but was #{footer}")
+    assert(footer.include?(ending_snippet),
+           "expected footer to include ending snippet: #{ending_snippet}, but was #{footer}")
   end
 
   def test_browser_timing_footer_with_no_beacon_configuration
     browser_timing_header
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns( nil)
     footer = browser_timing_footer
     assert_equal "", footer
   end
 
-
   def test_browser_timing_footer_disable_all_tracing
     browser_timing_header
     footer = nil
@@ -148,30 +175,31 @@ var e=document.createElement("script");'
     assert_equal "", footer
   end
 
-  def test_browser_timing_footer_browser_monitoring_key_missing
-    fake_config = mock('beacon configuration')
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_config)
-    fake_config.expects(:nil?).returns(false)
-    fake_config.expects(:rum_enabled).returns(true)
-    fake_config.expects(:browser_monitoring_key).returns(nil)
-    self.expects(:generate_footer_js).never
-    assert_equal('', browser_timing_footer, "should not return a footer when there is no key")
+  def test_browser_timing_footer_browser_key_missing
+    with_config(:browser_key => '') do
+      fake_config = mock('beacon configuration')
+      NewRelic::Agent.instance.stubs(:beacon_configuration).returns(fake_config)
+      fake_config.expects(:nil?).returns(false)
+      fake_config.expects(:enabled?).returns(true)
+      self.expects(:generate_footer_js).never
+      assert_equal('', browser_timing_footer, "should not return a footer when there is no key")
+    end
   end
 
   def test_generate_footer_js_null_case
     self.expects(:browser_monitoring_start_time).returns(nil)
     assert_equal('', generate_footer_js(NewRelic::Agent.instance.beacon_configuration), "should not send javascript when there is no start time")
   end
- 
+
   def test_generate_footer_js_with_start_time
-    self.expects(:browser_monitoring_start_time).returns(Time.at(100))
-    fake_bc = mock('beacon configuration')
-    fake_bc.expects(:application_id).returns(1)
-    fake_bc.expects(:beacon).returns('beacon')
-    fake_bc.expects(:browser_monitoring_key).returns('a' * 40)
-    NewRelic::Agent.instance.stubs(:beacon_configuration).returns(fake_bc)
-    self.expects(:footer_js_string).with(NewRelic::Agent.instance.beacon_configuration, 'beacon', 'a' * 40, 1).returns('footer js')
-    assert_equal('footer js', generate_footer_js(NewRelic::Agent.instance.beacon_configuration), 'should generate and return the footer JS when there is a start time')
+    with_config(:browser_key => 'a' * 40) do
+      self.expects(:browser_monitoring_start_time).returns(Time.at(100))
+      fake_bc = mock('beacon configuration')
+      NewRelic::Agent.instance.stubs(:beacon_configuration).returns(fake_bc)
+      self.expects(:footer_js_string).with(NewRelic::Agent.instance.beacon_configuration).returns('footer js')
+      assert_equal('footer js', generate_footer_js(NewRelic::Agent.instance.beacon_configuration),
+                   'should generate and return the footer JS when there is a start time')
+    end
   end
 
   def test_browser_monitoring_transaction_name_basic
@@ -193,27 +221,23 @@ var e=document.createElement("script");'
   def test_browser_monitoring_transaction_name_nil
     assert_equal('(unknown)', browser_monitoring_transaction_name, "should fill in a default when it is nil")
   end
-  
+
   def test_browser_monitoring_transaction_name_when_tt_disabled
-    @sampler = NewRelic::Agent.instance.transaction_sampler
-    @sampler.disable
+    with_config(:'transaction_tracer.enabled' => false) do
+      perform_action_with_newrelic_trace(:name => 'disabled_transactions') do
+        self.class.inspect
+      end
 
-    perform_action_with_newrelic_trace(:name => 'disabled_transactions') do
-      self.class.inspect
+      assert_match(/disabled_transactions/, browser_monitoring_transaction_name,
+                   "should name transaction when transaction tracing disabled")
     end
-        
-    assert_match(/disabled_transactions/, browser_monitoring_transaction_name,
-                 "should name transaction when transaction tracing disabled")
-  ensure
-    @sampler.enable
-  end
-  
-  
+  end
+
   def test_browser_monitoring_start_time
     mock = mock('transaction info')
-    
+
     NewRelic::Agent::TransactionInfo.set(mock)
-    
+
     mock.stubs(:start_time).returns(Time.at(100))
     mock.stubs(:guid).returns('ABC')
     assert_equal(Time.at(100), browser_monitoring_start_time, "should take the value from the thread local")
@@ -228,7 +252,7 @@ var e=document.createElement("script");'
   def test_browser_monitoring_app_time_nonzero
     start = Time.now
     self.expects(:browser_monitoring_start_time).returns(start - 1)
-    Time.expects(:now).returns(start)
+    Time.stubs(:now).returns(start)
     assert_equal(1000, browser_monitoring_app_time, 'should return a rounded time')
   end
 
@@ -255,10 +279,6 @@ var e=document.createElement("script");'
   end
 
   def test_footer_js_string_basic
-    beacon = ''
-    license_key = ''
-    application_id = 1
-
     # mocking this because JRuby thinks that Time.now - Time.now
     # always takes at least 1ms
     self.expects(:browser_monitoring_app_time).returns(0)
@@ -269,21 +289,21 @@ var e=document.createElement("script");'
 
     sample = mock('transaction info')
     NewRelic::Agent::TransactionInfo.set(sample)
-    
+
     sample.stubs(:start_time).returns(Time.at(100))
     sample.stubs(:guid).returns('ABC')
     sample.stubs(:transaction_name).returns('most recent transaction')
     sample.stubs(:include_guid?).returns(true)
     sample.stubs(:duration).returns(12.0)
     sample.stubs(:token).returns('0123456789ABCDEF')
-    
+
     self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'most recent transaction').returns('most recent transaction')
     self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'user').returns('user')
     self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'account').returns('account')
     self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'product').returns('product')
 
-    value = footer_js_string(NewRelic::Agent.instance.beacon_configuration, beacon, license_key, application_id)
-    assert_equal("<script type=\"text/javascript\">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push([\"nrfj\",\"\",\"\",1,\"most recent transaction\",0,0,new Date().getTime(),\"ABC\",\"0123456789ABCDEF\",\"user\",\"account\",\"product\"])</script>", value, "should return the javascript given some default values")
+    value = footer_js_string(NewRelic::Agent.instance.beacon_configuration)
+    assert_equal("<script type=\"text/javascript\">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";\ne.src=((\"http:\"===document.location.protocol)?\"http:\":\"https:\") + \"//\" +\n  \"this_is_my_file\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push([\"nrfj\",\"beacon\",\"browserKey\",5,\"most recent transaction\",0,0,new Date().getTime(),\"ABC\",\"0123456789ABCDEF\",\"user\",\"account\",\"product\"]);</script>", value, "should return the javascript given some default values")
   end
 
   def test_html_safe_if_needed_unsafed
@@ -320,4 +340,55 @@ var e=document.createElement("script");'
     output = obfuscate(NewRelic::Agent.instance.beacon_configuration, text)
     assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx', output, "should output obfuscated text")
   end
+
+  def test_no_mobile_response_header_if_no_mobile_request_header_given
+    request = Rack::Request.new({})
+    response = Rack::Response.new
+
+    NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
+    assert_nil response['X-NewRelic-Beacon-Url']
+  end
+
+  def test_no_mobile_response_header_if_mobile_request_header_is_false
+    request = Rack::Request.new('HTTP_X_NEWRELIC_MOBILE_TRACE' => 'false')
+    response = Rack::Response.new
+
+    NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
+    assert_nil response['X-NewRelic-Beacon-Url']
+  end
+
+  def test_place_beacon_url_header_when_given_mobile_request_header
+    response = mobile_transaction
+    assert_equal('http://beacon/mobile/1/browserKey',
+                 response['X-NewRelic-Beacon-Url'])
+  end
+
+  def test_place_beacon_url_header_when_given_mobile_request_header_with_https
+    request = Rack::Request.new('X_NEWRELIC_MOBILE_TRACE' => 'true',
+                                'rack.url_scheme' => 'https')
+    response = mobile_transaction(request)
+    assert_equal('https://beacon/mobile/1/browserKey',
+                 response['X-NewRelic-Beacon-Url'])
+  end
+
+  def test_place_beacon_payload_head_when_given_mobile_request_header
+    Time.stubs(:now).returns(6)
+    response = mobile_transaction
+    txn_name = obfuscate(NewRelic::Agent.instance.beacon_configuration,
+                         browser_monitoring_transaction_name)
+    expected_payload = %|["5","#{txn_name}",#{browser_monitoring_queue_time},#{browser_monitoring_app_time}]|
+
+    assert_equal expected_payload, response['X-NewRelic-App-Server-Metrics'].strip
+  end
+
+  def mobile_transaction(request=nil)
+    request ||= Rack::Request.new('X-NewRelic-Mobile-Trace' => 'true')
+    response = Rack::Response.new
+    txn_data = OpenStruct.new(:transaction_name => 'a transaction name',
+                              :start_time => 5,
+                              :force_persist_sample? => false)
+    NewRelic::Agent::TransactionInfo.set(txn_data)
+    NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
+    response
+  end
 end

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

@@ -0,0 +1,74 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/environment_source'
+
+module NewRelic::Agent::Configuration
+  class EnvironmentSourceTest < Test::Unit::TestCase
+    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_DISPATCHER', 'dispatcher'
+      assert_applied_string 'NEWRELIC_DISPATCHER', 'dispatcher'
+      assert_applied_string 'NEW_RELIC_FRAMEWORK', 'framework'
+      assert_applied_string 'NEWRELIC_FRAMEWORK', 'framework'
+    end
+
+    def test_environment_booleans_truths_are_applied
+      ENV['NEWRELIC_ENABLE'] = 'true'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'on'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'yes'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV.delete('NEWRELIC_ENABLE')
+    end
+
+    def test_environment_booleans_falsehoods_are_applied
+      ENV['NEWRELIC_ENABLE'] = 'false'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'off'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'no'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV.delete('NEWRELIC_ENABLE')
+    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_thread_profiler_is_supported
+      source = EnvironmentSource.new
+
+      assert_equal(
+        NewRelic::Agent::ThreadProfiler.is_supported?,
+        source[:'thread_profiler.is_supported'])
+    end
+
+    def test_thread_profiler_enabled_depending_on_support
+      source = EnvironmentSource.new
+
+      expected = false unless NewRelic::Agent::ThreadProfiler.is_supported?
+
+      assert_equal expected, source[:'thread_profiler.enabled']
+    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
+  end
+end

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

@@ -0,0 +1,149 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/manager'
+
+module NewRelic::Agent::Configuration
+  class ManagerTest < Test::Unit::TestCase
+    def setup
+      @manager = NewRelic::Agent::Configuration::Manager.new
+    end
+
+    def test_should_use_indifferent_access
+      config = NewRelic::Agent::Configuration::DottedHash.new('string' => 'string', :symbol => 'symbol')
+      @manager.apply_config(config)
+      assert_equal 'string', @manager[:string]
+      assert_equal 'symbol', @manager['symbol']
+      @manager.remove_config(config)
+    end
+
+    def test_should_apply_config_sources_in_order
+      config0 = {
+        :foo => 'default foo',
+        :bar => 'default bar',
+        :baz => 'default baz'
+      }
+      @manager.apply_config(config0)
+      config1 = { :foo => 'real foo' }
+      @manager.apply_config(config1)
+      config2 = { :foo => 'wrong foo', :bar => 'real bar' }
+      @manager.apply_config(config2, 1)
+
+      assert_equal 'real foo', @manager['foo']
+      assert_equal 'real bar', @manager['bar']
+      assert_equal 'default baz', @manager['baz']
+
+      @manager.remove_config(config0)
+      @manager.remove_config(config1)
+      @manager.remove_config(config2)
+    end
+
+    def test_identifying_config_source
+      hash_source = {:foo => 'foo', :bar => 'default'}
+      @manager.apply_config(hash_source)
+      test_source = TestSource.new
+      test_source[:bar] = 'bar'
+      test_source[:baz] = 'baz'
+      @manager.apply_config(test_source)
+
+      assert_not_equal test_source, @manager.source(:foo)
+      assert_equal test_source, @manager.source(:bar)
+      assert_equal test_source, @manager.source(:baz)
+
+      @manager.remove_config(hash_source)
+      @manager.remove_config(test_source)
+    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.apply_config(source)
+
+      assert_equal 'bar', @manager[:foo]
+      assert_equal '666', @manager[:simple_value]
+      assert_equal 'bar', @manager[:reference]
+
+      @manager.remove_config(source)
+    end
+
+    def test_should_not_apply_removed_sources
+      test_source = TestSource.new
+      @manager.apply_config(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.apply_config({:license_key => 'wrong'}, 1)
+
+      assert_equal 'right', manager['license_key']
+    end
+
+    def test_config_values_should_be_memoized
+      @manager.apply_config(:setting => 'correct value')
+      assert_equal 'correct value', @manager[:setting]
+
+      @manager.config_stack.unshift(:setting => 'wrong value')
+      assert_equal 'correct value', @manager[:setting]
+    end
+
+    def test_flattened_config
+      @manager.instance_variable_set(:@config_stack, [])
+      @manager.apply_config(:eins => Proc.new { self[:one] })
+      @manager.apply_config(:one => 1)
+      @manager.apply_config(:two => 2)
+      @manager.apply_config(:three => 3)
+
+      assert_equal({ :eins => 1, :one => 1, :two => 2, :three => 3 },
+                   @manager.flattened_config)
+    end
+
+    def test_replacing_a_layer_by_class
+      old_config = NewRelic::Agent::Configuration::ManualSource.new(:test => 'wrong')
+      @manager.apply_config(old_config, 1)
+      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.config_stack.size
+      assert_equal 1, @manager.config_stack.map{|s| s.class} \
+        .index(NewRelic::Agent::Configuration::ManualSource)
+    end
+
+    def test_registering_a_callback
+      observed_value = 'old'
+      @manager.apply_config(:test => 'original')
+
+      @manager.register_callback(:test) do |value|
+        observed_value = value
+      end
+      assert_equal 'original', observed_value
+
+      @manager.apply_config(:test => 'new')
+      assert_equal 'new', observed_value
+    end
+
+    def test_callback_not_called_if_no_change
+      @manager.apply_config(:test => true, :other => false)
+      @manager.register_callback(:test) do |value|
+        state = 'wrong'
+      end
+      state = 'right'
+      config = {:test => true}
+      @manager.apply_config(config)
+      @manager.remove_config(config)
+
+      assert_equal 'right', state
+    end
+
+    class TestSource < ::Hash
+      def test_config_accessor
+        'some value'
+      end
+    end
+  end
+end