newrelic_rpm 4.0.0.332 → 4.4.0.336

data/test/new_relic/agent/javascript_instrumentor_test.rb

@@ -1,340 +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/javascript_instrumentor"
-require "base64"
-
-class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
-  attr_reader :instrumentor
-
-  def setup
-    @config = {
-      :application_id         => '5, 6', # collector can return app multiple ids
-      :beacon                 => 'beacon',
-      :browser_key            => 'browserKey',
-      :js_agent_loader        => 'loader',
-      :license_key            => "\0",  # no-op obfuscation key
-      :'rum.enabled'          => true,
-      :disable_harvest_thread => true
-    }
-    NewRelic::Agent.config.add_config_for_testing(@config)
-
-    events = stub(:subscribe => nil)
-    @instrumentor = NewRelic::Agent::JavascriptInstrumentor.new(events)
-
-    # By default we expect our transaction to have a start time
-    # All sorts of basics don't output without this setup initially
-    NewRelic::Agent::TransactionState.tl_get.reset
-  end
-
-  def teardown
-    NewRelic::Agent::TransactionState.tl_clear_for_testing
-    NewRelic::Agent.config.reset_to_defaults
-  end
-
-  def test_js_errors_beta_default_gets_default_loader
-    assert_equal "rum", NewRelic::Agent.config[:'browser_monitoring.loader']
-  end
-
-  def test_js_errors_beta_gets_full_loader
-    with_config(:js_errors_beta => true) do
-      assert_equal "full", NewRelic::Agent.config[:'browser_monitoring.loader']
-    end
-  end
-
-  def test_js_errors_beta_off_gets_default_loader
-    with_config(:js_errors_beta => false) do
-      assert_equal "rum", NewRelic::Agent.config[:'browser_monitoring.loader']
-    end
-  end
-
-  def test_auto_instrumentation_config_defaults_to_enabled
-    assert NewRelic::Agent.config[:'browser_monitoring.auto_instrument']
-  end
-
-  def test_browser_timing_header_outside_transaction
-    assert_equal "", instrumentor.browser_timing_header
-  end
-
-  def test_browser_timing_scripts_with_rum_enabled_false
-    with_config(:'rum.enabled' => false) do
-      in_transaction do
-        assert_equal "", instrumentor.browser_timing_header
-      end
-    end
-  end
-
-  def test_browser_timing_header_disable_transaction_tracing
-    in_transaction do
-      NewRelic::Agent.disable_transaction_tracing do
-        assert_equal "", instrumentor.browser_timing_header
-      end
-    end
-  end
-
-  def test_browser_timing_header_disable_all_tracing
-    in_transaction do
-      NewRelic::Agent.disable_all_tracing do
-        assert_equal "", instrumentor.browser_timing_header
-      end
-    end
-  end
-
-  def test_browser_timing_header_without_loader
-    with_config(:js_agent_loader => '') do
-      in_transaction do
-        assert_equal "", instrumentor.browser_timing_header
-      end
-    end
-  end
-
-  def test_browser_timing_header_without_beacon
-    with_config(:beacon => '') do
-      in_transaction do
-        assert_equal "", instrumentor.browser_timing_header
-      end
-    end
-  end
-
-  def test_browser_timing_header_without_browser_key
-    with_config(:browser_key => '') do
-      in_transaction do
-        assert_equal "", instrumentor.browser_timing_header
-      end
-    end
-  end
-
-  def test_browser_timing_header_with_ignored_enduser
-    in_transaction do |txn|
-      txn.ignore_enduser!
-      assert_equal "", instrumentor.browser_timing_header
-    end
-  end
-
-  def test_browser_timing_header_with_default_settings
-    in_transaction do
-      header = instrumentor.browser_timing_header
-      assert_has_js_agent_loader(header)
-      assert_has_text(BEGINNING_OF_FOOTER, header)
-      assert_has_text(END_OF_FOOTER, header)
-    end
-  end
-
-  def test_browser_timing_header_safe_when_insert_js_fails
-    in_transaction do
-      begin
-        NewRelic::Agent.stubs(:config).raises("Hahahaha")
-        assert_equal "", instrumentor.browser_timing_header
-      ensure
-        # stopping the transaction touches config, so we need to ensure we
-        # clean up after ourselves here.
-        NewRelic::Agent.unstub(:config)
-      end
-    end
-  end
-
-  def test_browser_timing_header_safe_when_loader_generation_fails
-    in_transaction do
-      instrumentor.stubs(:html_safe_if_needed).raises("Hahahaha")
-      assert_equal "", instrumentor.browser_timing_header
-    end
-  end
-
-  def test_browser_timing_header_safe_when_json_dump_fails
-    in_transaction do
-      ::JSON.stubs(:dump).raises("Serialize? Hahahaha")
-      assert_equal "", instrumentor.browser_timing_header
-    end
-  end
-
-  def test_config_data_for_js_agent
-    freeze_time
-    with_config(CAPTURE_ATTRIBUTES => true) do
-      in_transaction('most recent transaction') do
-        txn = NewRelic::Agent::Transaction.tl_current
-        txn.stubs(:queue_time).returns(0)
-        txn.stubs(:start_time).returns(Time.now - 10)
-        txn.stubs(:guid).returns('ABC')
-
-        state = NewRelic::Agent::TransactionState.tl_get
-
-        data = instrumentor.data_for_js_agent(state)
-        expected = {
-          "beacon"          => "beacon",
-          "errorBeacon"     => "",
-          "licenseKey"      => "browserKey",
-          "applicationID"   => "5, 6",
-          "transactionName" => pack("most recent transaction"),
-          "queueTime"       => 0,
-          "applicationTime" => 10000,
-          "agent"           => ""
-        }
-
-        js = instrumentor.browser_timing_config(state)
-        expected.each do |key, value|
-          assert_equal(value, data[key])
-          assert_match(/"#{key.to_s}":#{formatted_for_matching(value)}/, js)
-        end
-      end
-    end
-  end
-
-  def test_config_data_for_js_agent_attributes
-    freeze_time
-    with_config(CAPTURE_ATTRIBUTES => true) do
-      in_transaction('most recent transaction') do
-        NewRelic::Agent.add_custom_attributes(:user => "user")
-        NewRelic::Agent::Transaction.add_agent_attribute(:agent, "attribute", NewRelic::Agent::AttributeFilter::DST_ALL)
-
-        state = NewRelic::Agent::TransactionState.tl_get
-        data = instrumentor.data_for_js_agent(state)
-
-        # Handle packed atts key specially since it's obfuscated
-        actual = unpack_to_object(data["atts"])
-        expected = {
-          "u" => {"user" => "user"},
-          "a" => {"agent" => "attribute"}
-        }
-        assert_equal expected, actual
-      end
-    end
-  end
-
-  def test_ssl_for_http_not_included_by_default
-    state = NewRelic::Agent::TransactionState.tl_get
-    data = instrumentor.data_for_js_agent(state)
-    assert_not_includes data, "sslForHttp"
-  end
-
-  def test_ssl_for_http_enabled
-    with_config(:'browser_monitoring.ssl_for_http' => true) do
-      state = NewRelic::Agent::TransactionState.tl_get
-      data = instrumentor.data_for_js_agent(state)
-      assert data["sslForHttp"]
-    end
-  end
-
-  def test_ssl_for_http_disabled
-    with_config(:'browser_monitoring.ssl_for_http' => false) do
-      state = NewRelic::Agent::TransactionState.tl_get
-      data = instrumentor.data_for_js_agent(state)
-      assert_false data["sslForHttp"]
-    end
-  end
-
-  ATTRIBUTES_ENABLED = :'browser_monitoring.attributes.enabled'
-  CAPTURE_ATTRIBUTES = :'browser_monitoring.capture_attributes'
-
-  def test_data_for_js_agent_doesnt_get_custom_attributes_by_default
-    with_config({}) do
-      in_transaction do
-        NewRelic::Agent.add_custom_attributes({:boo => "hoo"})
-        assert_attributes_missing
-      end
-    end
-  end
-
-  def test_data_for_js_agent_doesnt_get_custom_attributes_outside_transaction
-    with_config(CAPTURE_ATTRIBUTES => true) do
-      NewRelic::Agent.add_custom_attributes({:boo => "hoo"})
-      assert_attributes_missing
-    end
-  end
-
-
-  def test_data_for_js_agent_gets_custom_attributes_with_old_config
-    with_config(CAPTURE_ATTRIBUTES => true) do
-      in_transaction do
-        NewRelic::Agent.add_custom_attributes({:boo => "hoo"})
-        assert_attributes_are('{"u":{"boo":"hoo"}}')
-      end
-    end
-  end
-
-  def test_data_for_js_agent_gets_custom_attributes_when_configured
-    with_config(ATTRIBUTES_ENABLED => true) do
-      in_transaction do
-        NewRelic::Agent.add_custom_attributes({:boo => "hoo"})
-        assert_attributes_are('{"u":{"boo":"hoo"}}')
-      end
-    end
-  end
-
-  def test_data_for_js_agent_ignores_custom_attributes_by_config
-    with_config(CAPTURE_ATTRIBUTES => false) do
-      in_transaction do
-        NewRelic::Agent.add_custom_attributes({:boo => "hoo"})
-        assert_attributes_missing
-      end
-    end
-  end
-
-  def test_html_safe_if_needed_unsafed
-    string = mock('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.expects(:respond_to?).with(:html_safe).returns(false)
-    assert_equal(string, instrumentor.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)
-    assert_equal(string, instrumentor.html_safe_if_needed(string))
-  end
-
-  # Helpers
-
-  BEGINNING_OF_FOOTER = '<script type="text/javascript">window.NREUM||(NREUM={});NREUM.info='
-  END_OF_FOOTER = '}</script>'
-
-  def assert_has_js_agent_loader(header)
-    assert_match(%Q[\n<script type=\"text/javascript\">loader</script>],
-                 header,
-                 "expected new JS agent loader 'loader' but saw '#{header}'")
-  end
-
-  def assert_has_text(snippet, footer)
-    assert(footer.include?(snippet), "Expected footer to include snippet: #{snippet}, but instead was #{footer}")
-  end
-
-  def assert_attributes_are(expected)
-    state = NewRelic::Agent::TransactionState.tl_get
-    data = instrumentor.data_for_js_agent(state)
-    assert_equal pack(expected), data["atts"]
-  end
-
-  def assert_attributes_missing
-    state = NewRelic::Agent::TransactionState.tl_get
-    data = instrumentor.data_for_js_agent(state)
-    assert_not_includes data, "atts"
-  end
-
-  def pack(text)
-    [text].pack("m0").gsub("\n", "")
-  end
-
-  def unpack_to_object(text)
-    unpacked_atts = instrumentor.obfuscator.deobfuscate(text)
-    ::JSON.load(unpacked_atts)
-  end
-
-  def formatted_for_matching(value)
-    case value
-    when String
-      %Q["#{value}"]
-    when NilClass
-      "null"
-    else
-      value
-    end
-  end
-
-end

data/test/new_relic/agent/memory_logger_test.rb

@@ -1,85 +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/memory_logger'
-
-class MemoryLoggerTest < Minitest::Test
-  LEVELS = [:fatal, :error, :warn, :info, :debug]
-
-  def setup
-    @logger = NewRelic::Agent::MemoryLogger.new
-  end
-
-  def test_proxies_messages_to_real_logger_on_dump
-    LEVELS.each do |level|
-      @logger.send(level, "message at #{level}")
-    end
-
-    real_logger = mock
-
-    # This is needed for the expectation on #warn (also defined in Kernel) to
-    # work with old versions of Mocha.
-    def real_logger.warn(*); end
-
-    real_logger.expects(:fatal).with("message at fatal")
-    real_logger.expects(:error).with("message at error")
-    real_logger.expects(:warn).with("message at warn")
-    real_logger.expects(:info).with("message at info")
-    real_logger.expects(:debug).with("message at debug")
-
-    @logger.dump(real_logger)
-  end
-
-  def test_proxies_multiple_messages_with_a_single_call
-    @logger.info('a', 'b', 'c')
-
-    real_logger = stub
-    real_logger.expects(:info).with('a', 'b', 'c')
-
-    @logger.dump(real_logger)
-  end
-
-  def test_proxies_message_blocks
-    called = false
-    @logger.info do
-      called = true
-      'a'
-    end
-
-    real_logger = stub
-    real_logger.expects(:info).yields()
-
-    @logger.dump(real_logger)
-    assert called
-  end
-
-  def test_proxies_through_calls_to_log_exception
-    e = Exception.new
-    @logger.log_exception(:fatal, e, :error)
-
-    real_logger = stub
-    real_logger.expects(:log_exception).with(:fatal, e, :error)
-
-    @logger.dump(real_logger)
-  end
-
-  def test_log_once
-    @logger.log_once(:debug, :once, "Once")
-    @logger.log_once(:debug, :once, "Twice?")
-
-    real_logger = stub
-    real_logger.expects(:debug).once
-
-    @logger.dump(real_logger)
-  end
-
-  def test_implemented_agent_logger_interface
-    agent_logger_methods =  NewRelic::Agent::AgentLogger.instance_methods(false)
-    memory_logger_methods = NewRelic::Agent::MemoryLogger.instance_methods(false)
-
-    unimplemented = agent_logger_methods - memory_logger_methods
-    assert_empty unimplemented
-  end
-end

data/test/new_relic/agent/method_interrobang_test.rb

@@ -1,31 +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/method_tracer'
-
-class MethodInterrobangTest < Minitest::Test
-	include NewRelic::Agent::MethodTracer
-
-	def interrogate?
-		"say what?"
-	end
-
-	def mutate!
-		"oh yeah!"
-	end
-
-	add_method_tracer :interrogate?
-	add_method_tracer :mutate!
-
-	def test_alias_method_ending_in_question_mark
-		assert_respond_to self, :interrogate?
-		assert_equal "say what?", interrogate?
-	end
-
-	def test_alias_method_ending_in_exclamation_mark
-		assert_respond_to self, :mutate!
-		assert_equal "oh yeah!", mutate!
-	end
-end

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -1,112 +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 'set'
-module NewRelic
-  module Agent
-    class Agent
-      module MethodTracer
-        module ClassMethods
-          class AddMethodTracerTest < Minitest::Test
-            #  require 'new_relic/agent/method_tracer'
-            include NewRelic::Agent::MethodTracer::ClassMethods::AddMethodTracer
-
-            def test_validate_options_nonhash
-              assert_raises(TypeError) do
-                validate_options(:fluttershy, [])
-              end
-            end
-
-            def test_validate_options_defaults
-              self.expects(:check_for_illegal_keys!)
-              self.expects(:check_for_push_scope_and_metric)
-              validate_options(:applejack, {})
-            end
-
-            def test_validate_options_override
-              opts = {:push_scope => false, :metric => false, :force => true}
-              self.expects(:check_for_illegal_keys!)
-              self.expects(:check_for_push_scope_and_metric)
-              val = validate_options(:pinkie_pie, opts)
-              assert val.is_a?(Hash)
-              assert (val[:push_scope] == false), val.inspect
-              assert (val[:metric] == false), val.inspect
-              assert (val[:force] == true), val.inspect
-            end
-
-            def test_default_metric_name_code
-              assert_equal "Custom/#{self.class.name}/test_method", self.class.default_metric_name_code('test_method')
-            end
-
-            def test_newrelic_method_exists_positive
-              self.expects(:method_defined?).returns(true)
-              assert newrelic_method_exists?('test_method')
-            end
-
-            def test_newrelic_method_exists_negative
-              self.class.expects(:method_defined?).returns(false)
-              self.class.expects(:private_method_defined?).returns(false)
-
-              assert !self.class.newrelic_method_exists?('test_method')
-            end
-
-            def test_check_for_illegal_keys_positive
-              assert_raises(RuntimeError) do
-                check_for_illegal_keys!(:twilight_sparkle, {:unknown_key => nil})
-              end
-            end
-
-            def test_check_for_illegal_keys_negative
-              test_keys = Hash[*ALLOWED_KEYS.map {|x| [x, nil]}.flatten]
-              check_for_illegal_keys!(:rainbow_dash, test_keys)
-            end
-
-            def test_traced_method_exists_positive
-              self.expects(:_traced_method_name)
-              self.expects(:method_defined?).returns(true)
-              assert traced_method_exists?('test_method', 'Custom/Test/test_method')
-            end
-
-            def test_traced_method_exists_negative
-              self.expects(:_traced_method_name)
-              self.expects(:method_defined?).returns(false)
-              assert !traced_method_exists?(nil, nil)
-            end
-
-            def test_assemble_code_header_unforced
-              self.expects(:_untraced_method_name).returns("method_name_without_tracing")
-              opts = {:force => false, :code_header => 'CODE HEADER'}
-              assert_equal "return method_name_without_tracing(*args, &block) unless NewRelic::Agent.tl_is_execution_traced?\nCODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
-            end
-
-            def test_check_for_push_scope_and_metric_positive
-              check_for_push_scope_and_metric({:push_scope => true})
-              check_for_push_scope_and_metric({:metric => true})
-            end
-
-            def test_check_for_push_scope_and_metric_negative
-              assert_raises(RuntimeError) do
-                check_for_push_scope_and_metric({:push_scope => false, :metric => false})
-              end
-            end
-
-            def test_code_to_eval_scoped
-              self.expects(:validate_options).returns({:push_scope => true})
-              self.expects(:method_with_push_scope).with('test_method', 'Custom/Test/test_method', {:push_scope => true})
-              code_to_eval('test_method', 'Custom/Test/test_method', {})
-            end
-
-            def test_code_to_eval_unscoped
-              self.expects(:validate_options).returns({:push_scope => false})
-              self.expects(:method_without_push_scope).with('test', 'Custom/Test/test', {:push_scope => false})
-              code_to_eval('test', 'Custom/Test/test', {})
-            end
-          end
-        end
-      end
-    end
-  end
-end