newrelic_rpm 3.0.1 → 3.1.0.beta1

data/test/new_relic/agent/agent/start_worker_thread_test.rb

@@ -60,15 +60,13 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
   def test_create_and_run_worker_loop
     @report_period = 30
     @should_send_samples = true
-    fake_collector = mock('error collector')
-    self.expects(:error_collector).returns(fake_collector)
     wl = mock('worker loop')
     NewRelic::Agent::WorkerLoop.expects(:new).returns(wl)
     wl.expects(:run).with(30).yields
     self.expects(:harvest_and_send_timeslice_data)
     self.expects(:harvest_and_send_slowest_sample)
-    fake_collector.expects(:enabled).returns(true)
     self.expects(:harvest_and_send_errors)
+    NewRelic::Agent.expects(:load_data)
     create_and_run_worker_loop
   end
 

data/test/new_relic/agent/agent_test.rb

@@ -2,81 +2,126 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 module NewRelic
   module Agent
     class AgentTest < Test::Unit::TestCase
+
+      def setup
+        super
+        @agent = NewRelic::Agent::Agent.new
+      end
+
+      def test_serialize
+        assert_equal([{}, [], []], @agent.send(:serialize), "should return nil when shut down")
+      end
+
+      def test_harvest_transaction_traces
+        assert_equal([], @agent.send(:harvest_transaction_traces), 'should return transaction traces')
+      end
+
+      def test_harvest_timeslice_data
+        assert_equal({}, @agent.send(:harvest_timeslice_data), 'should return timeslice data')
+      end
+
+      def test_harvest_errors
+        assert_equal([], @agent.send(:harvest_errors), 'should return errors')
+      end
+
+      def test_merge_data_from_empty
+        unsent_timeslice_data = mock('unsent timeslice data')
+        unsent_errors = mock('unsent errors')
+        unsent_traces = mock('unsent traces')
+        @agent.instance_eval {
+          @unsent_errors = unsent_errors
+          @unsent_timeslice_data = unsent_timeslice_data
+          @traces = unsent_traces
+        }
+        # nb none of the others should receive merge requests
+        @agent.merge_data_from([{}])
+      end
+
+      def test_merge_data_from_all_three_empty
+        unsent_timeslice_data = mock('unsent timeslice data')
+        unsent_errors = mock('unsent errors')
+        unsent_traces = mock('unsent traces')
+        @agent.instance_eval {
+          @unsent_errors = unsent_errors
+          @unsent_timeslice_data = unsent_timeslice_data
+          @traces = unsent_traces
+        }
+        unsent_errors.expects(:+).with([])
+        unsent_traces.expects(:+).with([])
+        @agent.merge_data_from([{}, [], []])
+      end
+
       def test_sql_normalization
 
         # basic statement
         assert_equal "INSERT INTO X values(?,?, ? , ?)",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('test',0, 1 , 2)")
+        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('test',0, 1 , 2)")
 
         # escaped literals
         assert_equal "INSERT INTO X values(?, ?,?, ? , ?)",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son')")
+        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son')")
 
         # multiple string literals
         assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('jim''s ssn','x',0, 1 , 2)")
+        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('jim''s ssn','x',0, 1 , 2)")
 
         # empty string literal
         # NOTE: the empty string literal resolves to empty string, which for our purposes is acceptable
         assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('','x',0, 1 , 2)")
+        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('','x',0, 1 , 2)")
 
         # try a select statement
         assert_equal "select * from table where name=? and ssn=?",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, "select * from table where name='jim gochee' and ssn=0012211223")
+        @agent.send(:default_sql_obfuscator, "select * from table where name='jim gochee' and ssn=0012211223")
 
         # number literals embedded in sql - oh well
         assert_equal "select * from table_? where name=? and ssn=?",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, "select * from table_007 where name='jim gochee' and ssn=0012211223")
+        @agent.send(:default_sql_obfuscator, "select * from table_007 where name='jim gochee' and ssn=0012211223")
       end
 
       def test_sql_normalization__single_quotes
         assert_equal "INSERT ? into table",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT 'this isn''t a real value' into table")
+        @agent.send(:default_sql_obfuscator, "INSERT 'this isn''t a real value' into table")
         assert_equal "INSERT ? into table",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT '"' into table])
+        @agent.send(:default_sql_obfuscator, %q[INSERT '"' into table])
         assert_equal "INSERT ? into table",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT ' "some text" \" ' into table])
+        @agent.send(:default_sql_obfuscator, %q[INSERT ' "some text" \" ' into table])
         #    could not get this one licked.  no biggie
         #    assert_equal "INSERT ? into table",
-        #    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT '\'' into table])
+        #    @agent.send(:default_sql_obfuscator, %q[INSERT '\'' into table])
         assert_equal "INSERT ? into table",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT ''' ' into table])
+        @agent.send(:default_sql_obfuscator, %q[INSERT ''' ' into table])
       end
       def test_sql_normalization__double_quotes
         assert_equal "INSERT ? into table",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT "this isn't a real value" into table])
+        @agent.send(:default_sql_obfuscator, %q[INSERT "this isn't a real value" into table])
         assert_equal "INSERT ? into table",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT "'" into table])
+        @agent.send(:default_sql_obfuscator, %q[INSERT "'" into table])
         assert_equal "INSERT ? into table",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT " \" " into table])
+        @agent.send(:default_sql_obfuscator, %q[INSERT " \" " into table])
         assert_equal "INSERT ? into table",
-        NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT " 'some text' " into table])
+        @agent.send(:default_sql_obfuscator, %q[INSERT " 'some text' " into table])
       end
       def test_sql_obfuscation_filters
-        orig =  NewRelic::Agent.agent.obfuscator
-
-        NewRelic::Agent.set_sql_obfuscator(:replace) do |sql|
-          sql = "1" + sql
+        @agent.set_sql_obfuscator(:replace) do |string|
+          "1" + string
         end
 
         sql = "SELECT * FROM TABLE 123 'jim'"
 
-        assert_equal "1" + sql, NewRelic::Agent.instance.obfuscator.call(sql)
+        assert_equal "1" + sql, @agent.obfuscator.call(sql)
 
-        NewRelic::Agent.set_sql_obfuscator(:before) do |sql|
-          sql = "2" + sql
+        @agent.set_sql_obfuscator(:before) do |string|
+          "2" + string
         end
 
-        assert_equal "12" + sql, NewRelic::Agent.instance.obfuscator.call(sql)
+        assert_equal "12" + sql, @agent.obfuscator.call(sql)
 
-        NewRelic::Agent.set_sql_obfuscator(:after) do |sql|
-          sql = sql + "3"
+        @agent.set_sql_obfuscator(:after) do |string|
+          string + "3"
         end
 
-        assert_equal "12" + sql + "3", NewRelic::Agent.instance.obfuscator.call(sql)
-
-        NewRelic::Agent.agent.set_sql_obfuscator(:replace, &orig)
+        assert_equal "12" + sql + "3", @agent.obfuscator.call(sql)
       end
 
 

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -232,12 +232,12 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     engine = @agent.stats_engine
     get :entry_action
     assert_nil Thread.current[:newrelic_ignore_controller]
-    assert_nil engine.lookup_stat('Controller/agent_test/entry_action')
-    assert_nil engine.lookup_stat('Controller/agent_test_controller/entry_action')
-    assert_nil engine.lookup_stat('Controller/AgentTestController/entry_action')
-    assert_nil engine.lookup_stat('Controller/NewRelic::Agent::AgentTestController/internal_action')
-    assert_nil engine.lookup_stat('Controller/NewRelic::Agent::AgentTestController_controller/internal_action')
-    assert_not_nil engine.lookup_stat('Controller/NewRelic::Agent::AgentTestController/internal_traced_action')
+    assert_nil engine.lookup_stats('Controller/agent_test/entry_action')
+    assert_nil engine.lookup_stats('Controller/agent_test_controller/entry_action')
+    assert_nil engine.lookup_stats('Controller/AgentTestController/entry_action')
+    assert_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController/internal_action')
+    assert_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController_controller/internal_action')
+    assert_not_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController/internal_traced_action')
   end
   def test_action_instrumentation
     begin
@@ -271,23 +271,24 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     engine.clear_stats
 
     assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
-    get :index, 'social_security_number' => "001-555-1212", 'wait' => '1.0'
+    get :index, 'social_security_number' => "001-555-1212", 'wait' => '0.05'
     NewRelic::Agent::BusyCalculator.harvest_busy
 
     assert_equal 1, stats('Instance/Busy').call_count
     assert_equal 1, stats('HttpDispatcher').call_count
     # We are probably busy about 99% of the time, but lets make sure it's at least 50
-    assert stats('Instance/Busy').total_call_time > 0.5, stats('Instance/Busy').inspect
+    assert stats('Instance/Busy').total_call_time > (0.5 * 0.05), stats('Instance/Busy').inspect
     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
+    assert_not_nil bucket, "Bucket contents: #{bucket.inspect}, #{stats_engine.metrics.inspect}"
     bucket_stats = stats(bucket)
-    assert_equal 1, bucket_stats.call_count
+    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

data/test/new_relic/agent/beacon_configuration_test.rb

@@ -19,7 +19,7 @@ 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 86, bc.browser_timing_header.size
+    assert_equal 269, bc.browser_timing_header.size
   end
 
   def test_license_bytes_nil
@@ -36,7 +36,7 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
     NewRelic::Control.instance.expects(:license_key).never
     assert_equal([97] * 40, bc.license_bytes, "should return the cached value if it exists")
   end
-  
+
   def test_license_bytes_should_set_instance_cache
     connect_data = {}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
@@ -50,21 +50,38 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
     connect_data = {}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
     bc.instance_eval { @rum_enabled = false }
-    assert_equal '', bc.build_browser_timing_header, "should not return a header when rum enabled is false"
+    assert_equal '', bc.build_browser_timing_header(connect_data), "should not return a header when rum enabled is false"
   end
-  
+
   def test_build_browser_timing_header_enabled_but_no_key
     connect_data = {}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
     bc.instance_eval { @rum_enabled = true; @browser_monitoring_key = nil }
-    assert_equal '', bc.build_browser_timing_header, "should not return a header when browser_monitoring_key is nil"
+    assert_equal '', bc.build_browser_timing_header(connect_data), "should not return a header when browser_monitoring_key is nil"
   end
-  
+
+  def test_build_browser_timing_header_enabled_checking_for_episodes_url
+    connect_data = {'episodes_url' => 'an episodes url'}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @rum_enabled = true; @browser_monitoring_key = 'a' * 40 }
+    assert(bc.build_browser_timing_header(connect_data).include?('an episodes url'), "should include the episodes url in the javascript")
+  end
+
   def test_build_browser_timing_header_enabled_with_key
     connect_data = {}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
     bc.instance_eval { @browser_monitoring_key = 'a browser monitoring key' }
-    assert(bc.build_browser_timing_header.include?('NREUMQ'), "header should be generated when rum is enabled and browser monitoring key is set")
+    bc.expects(:load_file_js).with({}).returns('load file js')
+    assert(bc.build_browser_timing_header(connect_data).include?('load file js'), "header should be generated when rum is enabled and browser monitoring key is set")
+  end
+
+  def test_basic_javascript
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    mock_data = mock('connect data')
+    bc.expects(:load_file_js).with(mock_data)
+    # should just pass through the data
+    bc.basic_javascript(mock_data)
   end
 
   def test_build_browser_timing_header_should_html_safe_header
@@ -72,33 +89,33 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
     connect_data = {'browser_key' => 'a' * 40}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
     assert_equal('a' * 40, bc.instance_variable_get('@browser_monitoring_key'), "should save the key from the config")
-    bc.expects(:javascript_header).returns(mock_javascript)
+    bc.expects(:basic_javascript).with(connect_data).returns(mock_javascript)
     mock_javascript.expects(:respond_to?).with(:html_safe).returns(true)
     mock_javascript.expects(:html_safe)
-    bc.build_browser_timing_header
+    bc.build_browser_timing_header(connect_data)
   end
-  
-  def test_build_load_file_js_load_episodes_file_false
+
+  def test_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"
+    assert_equal '', bc.load_file_js(connect_data), "should be empty when load episodes file is false"
   end
-  
-  def test_build_load_file_js_load_episodes_file_missing
+
+  def test_load_file_js_load_episodes_file_missing
     connect_data = {}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert_equal(159, bc.build_load_file_js(connect_data).size, "should output the javascript when there is no configuration")
+    assert_equal(183, bc.load_file_js(connect_data).size, "should output the javascript when there is no configuration")
   end
 
-  def test_build_load_file_js_load_episodes_file_present
+  def test_load_file_js_load_episodes_file_present
     connect_data = {'rum.load_episodes_file' => true}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert_equal(159, bc.build_load_file_js(connect_data).size, "should output the javascript when rum.load_episodes_file is true")
+    assert_equal(183, bc.load_file_js(connect_data).size, "should output the javascript when rum.load_episodes_file is true")
   end
-  
-  def test_build_load_file_js_load_episodes_file_with_episodes_url
+
+  def test_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.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

@@ -30,13 +30,13 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
 
   def test_browser_timing_header
     header = browser_timing_header
-    assert_equal "<script>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header
+    assert_equal "<script>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);(function(){var d=document;var e=d.createElement(\"script\");e.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})()</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>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header
+    assert_equal "<script>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);(function(){var d=document;var e=d.createElement(\"script\");e.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})()</script>", header
   end
 
   def test_browser_timing_header_with_rum_enabled_false
@@ -68,15 +68,14 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     Thread.current[:newrelic_start_time] = Time.now
 
     footer = browser_timing_footer
-    snippet = "<script>(function(){var d=document;var e=d.createElement(\"script\");e.async=true;e.src=\"this_is_my_file\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})();NREUMQ.push([\"nrf2\","
-    assert footer.include?(snippet), "Expected footer to include snippet: #{snippet}, but instead was #{footer}"
+    assert footer.include?("<script type=\"text/javascript\" charset=\"utf-8\">NREUMQ.push([\"nrf2\",")
   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"}))
@@ -101,10 +100,8 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     config.expects(:license_bytes).returns(license_bytes)
     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\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})();NREUMQ.push([\"nrf2\","
-    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}")
+    assert footer.include?("<script type=\"text/javascript\" charset=\"utf-8\">NREUMQ.push([\"nrf2\",")
+    assert footer.include?("])</script>")
   end
 
   def test_browser_timing_footer_with_no_beacon_configuration
@@ -155,13 +152,13 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     self.expects(:browser_monitoring_start_time).returns(nil)
     assert_equal('', generate_footer_js, "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)    
+    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')
@@ -171,7 +168,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     Thread.current[:newrelic_most_recent_transaction] = '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] = ''
     assert_equal('', browser_monitoring_transaction_name, "should take the value even when it is empty")
@@ -204,7 +201,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     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
     assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is zero queue time')
@@ -213,7 +210,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   def test_browser_monitoring_queue_time_ducks
     Thread.current[:newrelic_queue_time] = 'a duck'
     assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is an incorrect queue time')
-  end    
+  end
 
   def test_browser_monitoring_queue_time_nonzero
     Thread.current[:newrelic_queue_time] = 3.00002
@@ -232,9 +229,9 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     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>(function(){var d=document;var e=d.createElement("script");e.async=true;e.src="this_is_my_file";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")
+    assert_equal('<script type="text/javascript" charset="utf-8">NREUMQ.push(["nrf2","","",1,"most recent transaction",0,0])</script>', value, "should return the javascript given some default values")
   end
 
   def test_html_safe_if_needed_unsafed
@@ -245,14 +242,14 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     string.expects(:respond_to?).with(:html_safe).returns(false)
     assert_equal(string, html_safe_if_needed(string))
   end
-  
+
   def test_html_safe_if_needed_safed
     string = mock('string')
     string.expects(:respond_to?).with(:html_safe).returns(true)
     string.expects(:html_safe).returns(string)
     # here to handle 1.9 encoding - we stub this out because it should
     # be handled automatically and is outside the scope of this test
-    string.stubs(:respond_to?).with(:encoding).returns(false)    
+    string.stubs(:respond_to?).with(:encoding).returns(false)
     assert_equal(string, html_safe_if_needed(string))
   end
 
@@ -263,12 +260,4 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     output = obfuscate(text)
     assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1', output, "should output obfuscated text")
   end
-
-  def test_obfuscate_long_string
-    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)
-    assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx', output, "should output obfuscated text")
-  end
 end