ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/test/new_relic/agent/agent_test_controller.rb

@@ -7,7 +7,7 @@ class NewRelic::Agent::SuperclassController <  ActionController::Base
 end
 # This is a controller class used in testing controller instrumentation
 class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassController
-  filter_parameter_logging :social_security_number
+  # filter_parameter_logging :social_security_number
 
   @@headers_to_add = nil
 

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -7,23 +7,24 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   self.controller_class = NewRelic::Agent::AgentTestController
 
   attr_accessor :agent, :engine
-
-  # Normally you can do this with #setup but for some reason in rails 2.0.2
-  # setup is not called.
-  def initialize name
-    super name
-
+  
+  def test_initialization
   # Suggested by cee-dub for merb tests.  I'm actually amazed if our tests work with merb.
-  if defined?(Merb::Router)
-    Merb::Router.prepare do |r|
-      match('/:controller(/:action)(.:format)').register
-    end
-  else
-    ActionController::Routing::Routes.draw do | map |
-      map.connect '/:controller/:action.:format'
-      map.connect '/:controller/:action'
+    if defined?(Merb::Router)
+      Merb::Router.prepare do |r|
+        match('/:controller(/:action)(.:format)').register
       end
-  end
+    elsif NewRelic::Control.instance.rails_version < NewRelic::VersionNumber.new("3.0")
+      ActionController::Routing::Routes.draw do |map|
+        map.connect '/:controller/:action.:format'
+        map.connect '/:controller/:action'
+      end
+    else
+      Rails.application.routes.draw do
+        match '/:controller/:action.:format'
+        match '/:controller/:action'
+      end    
+    end
 
     if defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:routes)
       @routes = Rails.application.routes
@@ -40,6 +41,17 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     end
     @engine = @agent.stats_engine
   end
+  
+  # Normally you can do this with #setup but for some reason in rails 2.0.2
+  # setup is not called.
+  if NewRelic::Control.instance.rails_version <= '2.1.0'
+    def initialize name
+      super name
+      test_initialization
+    end
+  else
+    alias_method :setup, :test_initialization
+  end
 
   def teardown
     Thread.current[:newrelic_ignore_controller] = nil
@@ -71,6 +83,9 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
 
   def test_new_queue_integration
+    # make this test deterministic
+    Time.stubs(:now => Time.at(2))
+
     NewRelic::Agent::AgentTestController.clear_headers
     engine.clear_stats
     start = ((Time.now - 1).to_f * 1_000_000).to_i
@@ -82,6 +97,9 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
 
 
   def test_new_middleware_integration
+    # make this test deterministic
+    Time.stubs(:now => Time.at(2))
+
     engine.clear_stats
     start = ((Time.now - 1).to_f * 1_000_000).to_i
     NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_MIDDLEWARE_START'=> "t=#{start}"
@@ -91,6 +109,9 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
 
   def test_new_server_time_integration
+    # make this test deterministic
+    Time.stubs(:now => Time.at(2))
+
     NewRelic::Agent::AgentTestController.clear_headers
     engine.clear_stats
     start = ((Time.now - 1).to_f * 1_000_000).to_i
@@ -101,6 +122,9 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
 
   def test_new_frontend_work_integration
+    # make this test deterministic
+    Time.stubs(:now => Time.at(10))
+
     engine.clear_stats
     times = [Time.now - 3, Time.now - 2, Time.now - 1]
     times.map! {|t| (t.to_f * 1_000_000).to_i }
@@ -240,12 +264,8 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_not_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController/internal_traced_action')
   end
   def test_action_instrumentation
-    begin
-      get :index, :foo => 'bar'
-      assert_match /bar/, @response.body
-      #rescue ActionController::RoutingError
-      # you might get here if you don't have the default route installed.
-    end
+    get :index, :foo => 'bar'
+    assert_match /bar/, @response.body
   end
 
   def test_controller_params
@@ -263,13 +283,12 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     get :index, 'number' => "001-555-1212"
     s = agent.transaction_sampler.harvest(nil, 0.0)
     assert_equal 1, s.size
-    assert_equal 5, s.first.params.size
+    assert_equal 6, s.first.params.size
   end
 
 
   def test_busycalculation
     engine.clear_stats
-
     assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
     get :index, 'social_security_number' => "001-555-1212", 'wait' => '0.05'
     NewRelic::Agent::BusyCalculator.harvest_busy
@@ -281,16 +300,6 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_equal 0, stats('WebFrontend/Mongrel/Average Queue Time').call_count
   end
 
-  def test_histogram
-    engine.clear_stats
-    get :index, 'social_security_number' => "001-555-1212"
-    stats_engine = NewRelic::Agent.instance.stats_engine
-    bucket = NewRelic::Agent.instance.stats_engine.metrics.find { | m | m =~ /^Response Times/ }
-    assert_not_nil bucket, "Bucket contents: #{bucket.inspect}, #{stats_engine.metrics.inspect}"
-    bucket_stats = stats(bucket)
-    assert_equal 1, bucket_stats.call_count, "expected the bucket to have a call, but instead got: #{bucket_stats.inspect}"
-  end
-
   def test_queue_headers_no_header
     engine.clear_stats
     queue_length_stat = stats('Mongrel/Queue Length')
@@ -302,6 +311,9 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
 
   def test_queue_headers_apache
+    # make this test deterministic
+    Time.stubs(:now => Time.at(10))
+
     NewRelic::Agent::AgentTestController.clear_headers
     engine.clear_stats
     queue_length_stat = stats('Mongrel/Queue Length')
@@ -318,6 +330,8 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
 
   end
   def test_queue_headers_heroku
+    # make this test deterministic
+    Time.stubs(:now => Time.at(10))
 
     engine.clear_stats
     NewRelic::Agent::AgentTestController.clear_headers
@@ -336,6 +350,8 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
 
   def test_queue_headers_heroku_queue_length
+    # make this test deterministic
+    Time.stubs(:now => Time.at(10))
 
     engine.clear_stats
     NewRelic::Agent::AgentTestController.clear_headers

data/test/new_relic/agent/beacon_configuration_test.rb

@@ -19,7 +19,8 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
     assert_equal('a browser monitoring key', bc.browser_monitoring_key)
     assert_equal('an application id', bc.application_id)
     assert_equal('a beacon', bc.beacon)
-    assert_equal(109, bc.browser_timing_header.size, "should output the javascript with all the data available")
+    s = "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>"
+    assert_equal(s, bc.browser_timing_header)
   end
 
   def test_license_bytes_nil
@@ -81,24 +82,30 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
   def test_build_load_file_js_load_episodes_file_false
     connect_data = {'rum.load_episodes_file' => false}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert_equal '', bc.build_load_file_js(connect_data), "should be empty when load episodes file is false"
+    s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+    assert_equal(s, bc.build_load_file_js(connect_data))
   end
   
   def test_build_load_file_js_load_episodes_file_missing
     connect_data = {}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert_equal(184, bc.build_load_file_js(connect_data).size, "should output the javascript when there is no configuration")
+    s = "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=\"\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+    
+    assert_equal(s, bc.build_load_file_js(connect_data))
   end
 
   def test_build_load_file_js_load_episodes_file_present
     connect_data = {'rum.load_episodes_file' => true}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert_equal(184, bc.build_load_file_js(connect_data).size, "should output the javascript when rum.load_episodes_file is true")
+    s = "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=\"\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+    
+    assert_equal(s, bc.build_load_file_js(connect_data))
   end
   
   def test_build_load_file_js_load_episodes_file_with_episodes_url
     connect_data = {'episodes_url' => 'an episodes url'}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert(bc.build_load_file_js(connect_data).include?('an episodes url'), "should include the episodes url by default")
+    assert(bc.build_load_file_js(connect_data).include?('an episodes url'),
+           "should include the episodes url by default")
   end
 end

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -4,22 +4,41 @@ require "new_relic/agent/browser_monitoring"
 
 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"
     @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"})
+      @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})
     end
-    Thread.current[:newrelic_most_recent_transaction] = "MyCoolTransaction"
+    Thread.current[:last_metric_frame] = nil
+    NewRelic::Agent::TransactionInfo.clear
   end
 
   def teardown
     mocha_teardown
-    Thread.current[:newrelic_start_time] = nil
-    Thread.current[:newrelic_metric_frame] = nil
-    Thread.current[:newrelic_most_recent_transaction] = nil
+  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={});
+      # noop; instrument me
+    end
+    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)
+
+    # 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
 
   def test_browser_timing_header_with_no_beacon_configuration
@@ -30,13 +49,13 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
 
   def test_browser_timing_header
     header = browser_timing_header
-    assert_equal "<script type=\"text/javascript\">var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", 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_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"}))
     header = browser_timing_header
-    assert_equal "<script type=\"text/javascript\">var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", 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
@@ -65,18 +84,13 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     browser_timing_header
     NewRelic::Control.instance.expects(:license_key).returns("a" * 13)
 
-    Thread.current[:newrelic_start_time] = Time.now
-
     footer = browser_timing_footer
-    snippet = "<script type=\"text/javascript\">(function(){var d=document;var e=d.createElement(\"script\");e.async=true;e.src=\"this_is_my_file\";e.type=\"text/javascript\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})();NREUMQ.push([\"nrf2\","
+    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}"
   end
 
-  def test_browser_timing_footer_without_calling_header
-    footer = browser_timing_footer
-    assert_equal "", footer
-  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"}))
@@ -93,15 +107,16 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
 
   def test_browser_timing_footer_with_rum_enabled_not_specified
     browser_timing_header
-    Thread.current[:newrelic_start_time] = Time.now
 
     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.expects(:license_bytes).returns(license_bytes)
+    config.expects(:license_bytes).returns(license_bytes).at_least_once
     NewRelic::Agent.instance.expects(:beacon_configuration).returns(config).at_least_once
     footer = browser_timing_footer
-    beginning_snippet = "(function(){var d=document;var e=d.createElement(\"script\");e.async=true;e.src=\"this_is_my_file\";e.type=\"text/javascript\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})();NREUMQ.push([\"nrf2\","
+    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}")
@@ -114,14 +129,6 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     assert_equal "", footer
   end
 
-  def test_browser_timing_footer_with_no_start_time
-    browser_timing_header
-    Thread.current[:newrelic_start_time] = nil
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
-    footer = browser_timing_footer
-    assert_equal('', footer)
-  end
-
 
   def test_browser_timing_footer_disable_all_tracing
     browser_timing_header
@@ -153,37 +160,62 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
 
   def test_generate_footer_js_null_case
     self.expects(:browser_monitoring_start_time).returns(nil)
-    assert_equal('', generate_footer_js, "should not send javascript when there is no start time")
+    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.expects(:beacon_configuration).returns(fake_bc)
-    self.expects(:footer_js_string).with('beacon', 'a' * 40, 1).returns('footer js')
-    assert_equal('footer js', generate_footer_js, 'should generate and return the footer JS when there is a start time')
+    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')
   end
 
   def test_browser_monitoring_transaction_name_basic
-    Thread.current[:newrelic_most_recent_transaction] = 'a transaction name'
+    mock = mock('transaction sample')
+    NewRelic::Agent::TransactionInfo.set(mock)
+    mock.stubs(:transaction_name).returns('a transaction name')
+
     assert_equal('a transaction name', browser_monitoring_transaction_name, "should take the value from the thread local")
   end
 
   def test_browser_monitoring_transaction_name_empty
-    Thread.current[:newrelic_most_recent_transaction] = ''
+    mock = mock('transaction sample')
+    NewRelic::Agent::TransactionInfo.set(mock)
+
+    mock.stubs(:transaction_name).returns('')
     assert_equal('', browser_monitoring_transaction_name, "should take the value even when it is empty")
   end
 
   def test_browser_monitoring_transaction_name_nil
-    Thread.current[:newrelic_most_recent_transaction] = nil
-    assert_equal('<unknown>', browser_monitoring_transaction_name, "should fill in a default when it is 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
 
+    perform_action_with_newrelic_trace(:name => 'disabled_transactions') do
+      self.class.inspect
+    end
+        
+    assert_match(/disabled_transactions/, browser_monitoring_transaction_name,
+                 "should name transaction when transaction tracing disabled")
+  ensure
+    @sampler.enable
+  end
+  
+  
   def test_browser_monitoring_start_time
-    Thread.current[:newrelic_start_time] = Time.at(100)
+    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")
   end
 
@@ -201,22 +233,24 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_monitoring_queue_time_nil
-    Thread.current[:newrelic_queue_time] = nil
     assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is no queue time')
   end
 
   def test_browser_monitoring_queue_time_zero
-    Thread.current[:newrelic_queue_time] = 0.0
+    frame = Thread.current[:last_metric_frame] = mock('metric frame')
+    frame.expects(:queue_time).returns(0.0)
     assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is zero queue time')
   end
 
   def test_browser_monitoring_queue_time_ducks
-    Thread.current[:newrelic_queue_time] = 'a duck'
+    frame = Thread.current[:last_metric_frame] = mock('metric frame')
+    frame.expects(:queue_time).returns('a duck')
     assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is an incorrect queue time')
   end
 
   def test_browser_monitoring_queue_time_nonzero
-    Thread.current[:newrelic_queue_time] = 3.00002
+    frame = Thread.current[:last_metric_frame] = mock('metric frame')
+    frame.expects(:queue_time).returns(3.00002)
     assert_equal(3000, browser_monitoring_queue_time, 'should return a rounded time')
   end
 
@@ -225,16 +259,31 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     license_key = ''
     application_id = 1
 
-    Thread.current[:newrelic_queue_time] = nil
     # mocking this because JRuby thinks that Time.now - Time.now
     # always takes at least 1ms
     self.expects(:browser_monitoring_app_time).returns(0)
-    Thread.current[:newrelic_most_recent_transaction] = 'most recent transaction'
-
-    self.expects(:obfuscate).with('most recent transaction').returns('most recent transaction')
-
-    value = footer_js_string(beacon, license_key, application_id)
-    assert_equal('<script type="text/javascript">(function(){var d=document;var e=d.createElement("script");e.async=true;e.src="this_is_my_file";e.type="text/javascript";var s=d.getElementsByTagName("script")[0];s.parentNode.insertBefore(e,s);})();NREUMQ.push(["nrf2","","",1,"most recent transaction",0,0,new Date().getTime()])</script>', value, "should return the javascript given some default values")
+    frame = Thread.current[:last_metric_frame] = mock('metric frame')
+    user_attributes = {:user => "user", :account => "account", :product => "product"}
+    frame.expects(:user_attributes).returns(user_attributes).at_least_once
+    frame.expects(:queue_time).returns(0)
+
+    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")
   end
 
   def test_html_safe_if_needed_unsafed
@@ -260,7 +309,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     text = 'a happy piece of small text'
     key = (1..40).to_a
     NewRelic::Agent.instance.beacon_configuration.expects(:license_bytes).returns(key)
-    output = obfuscate(text)
+    output = obfuscate(NewRelic::Agent.instance.beacon_configuration, text)
     assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1', output, "should output obfuscated text")
   end
 
@@ -268,7 +317,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     text = 'a happy piece of small text' * 5
     key = (1..40).to_a
     NewRelic::Agent.instance.beacon_configuration.expects(:license_bytes).returns(key)
-    output = obfuscate(text)
+    output = obfuscate(NewRelic::Agent.instance.beacon_configuration, text)
     assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx', output, "should output obfuscated text")
   end
 end