ghazel-newrelic_rpm 3.1.0.1

data/test/new_relic/control_test.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
+class NewRelic::ControlTest < Test::Unit::TestCase
+
+  attr_reader :c
+
+  def setup
+
+    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
+    @c =  NewRelic::Control.instance
+    raise 'oh geez, wrong class' unless NewRelic::Control.instance.is_a?(::NewRelic::Control::Frameworks::Test)
+  end
+  def shutdown
+    NewRelic::Agent.shutdown
+  end
+
+  def test_cert_file_path
+    assert @c.cert_file_path
+    assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @c.cert_file_path
+  end
+  
+  # This test does not actually use the ruby agent in any way - it's
+  # testing that the CA file we ship actually validates our server's
+  # certificate. It's used for customers who enable verify_certificate
+  def test_cert_file
+    require 'socket'
+    require 'openssl'
+
+    s   = TCPSocket.new 'collector.newrelic.com', 443
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ca_file = @c.cert_file_path
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    s   = OpenSSL::SSL::SSLSocket.new s, ctx
+    s.connect
+    # should not raise an error
+  end
+  
+  # see above, but for staging, as well. This allows us to test new
+  # certificates in a non-customer-facing place before setting them
+  # live.
+  def test_staging_cert_file
+    require 'socket'
+    require 'openssl'
+
+    s   = TCPSocket.new 'staging-collector.newrelic.com', 443
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ca_file = @c.cert_file_path
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    s   = OpenSSL::SSL::SSLSocket.new s, ctx
+    s.connect
+    # should not raise an error
+  end
+
+  def test_monitor_mode
+    assert ! @c.monitor_mode?
+    @c.settings.delete 'enabled'
+    @c.settings.delete 'monitor_mode'
+    assert !@c.monitor_mode?
+    @c['enabled'] = false
+    assert ! @c.monitor_mode?
+    @c['enabled'] = true
+    assert @c.monitor_mode?
+    @c['monitor_mode'] = nil
+    assert !@c.monitor_mode?
+    @c['monitor_mode'] = false
+    assert !@c.monitor_mode?
+    @c['monitor_mode'] = true
+    assert @c.monitor_mode?
+  ensure
+    @c['enabled'] = false
+    @c['monitor_mode'] = false
+  end
+
+  def test_test_config
+    if defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
+      assert_equal :rails3, c.app
+    elsif defined?(Rails)
+      assert_equal :rails, c.app
+    else
+      assert_equal :test, c.app
+    end
+    assert_equal :test, c.framework
+    assert_match /test/i, c.dispatcher_instance_id
+    assert("" == c.dispatcher.to_s, "Expected dispatcher to be empty, but was #{c.dispatcher.to_s}")
+    assert !c['enabled']
+    assert_equal false, c['monitor_mode']
+    c.local_env
+  end
+
+  def test_root
+    assert File.directory?(NewRelic::Control.newrelic_root), NewRelic::Control.newrelic_root
+    if defined?(Rails)
+      assert File.directory?(File.join(NewRelic::Control.newrelic_root, "lib")), NewRelic::Control.newrelic_root +  "/lib"
+    end
+  end
+
+  def test_info
+    props = NewRelic::Control.instance.local_env.snapshot
+    if defined?(Rails)
+      assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last, props.inspect
+    end
+  end
+
+  def test_resolve_ip
+    assert_equal nil, c.send(:convert_to_ip_address, 'localhost')
+    assert_equal nil, c.send(:convert_to_ip_address, 'q1239988737.us')
+    # This will fail if you don't have a valid, accessible, DNS server
+    assert_equal '204.93.223.153', c.send(:convert_to_ip_address, 'collector.newrelic.com')
+  end
+
+  class FakeResolv
+    def self.getaddress(host)
+      raise 'deliberately broken'
+    end
+  end
+
+  def test_resolve_ip_with_broken_dns
+    # Here be dragons: disable the ruby DNS lookup methods we use so
+    # that it will actually fail to resolve.
+    old_resolv = Resolv
+    old_ipsocket = IPSocket
+    Object.instance_eval { remove_const :Resolv}
+    Object.instance_eval {remove_const:'IPSocket' }
+    assert_equal(nil, c.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+
+    Object.instance_eval {const_set('Resolv', old_resolv); const_set('IPSocket', old_ipsocket)}
+    # these are here to make sure that the constant tomfoolery above
+    # has not broket the system unduly
+    assert_equal old_resolv, Resolv
+    assert_equal old_ipsocket, IPSocket
+  end
+
+
+
+  def test_config_yaml_erb
+    assert_equal 'heyheyhey', c['erb_value']
+    assert_equal '', c['message']
+    assert_equal '', c['license_key']
+  end
+
+  def test_appnames
+    assert_equal %w[a b c], NewRelic::Control.instance.app_names
+  end
+
+  def test_config_booleans
+    assert_equal c['tval'], true
+    assert_equal c['fval'], false
+    assert_nil c['not_in_yaml_val']
+    assert_equal c['yval'], true
+    assert_equal c['sval'], 'sure'
+  end
+  def test_config_apdex
+    assert_equal 1.1, c.apdex_t
+  end
+#  def test_transaction_threshold
+#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
+#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+#  end
+  def test_log_file_name
+    NewRelic::Control.instance.setup_log
+    assert_match /newrelic_agent.log$/, c.instance_variable_get('@log_file')
+  end
+
+#  def test_transaction_threshold__apdex
+#    forced_start
+#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
+#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+#  end
+
+  def test_transaction_threshold__default
+
+    forced_start :transaction_tracer => { :transaction_threshold => nil}
+    assert_nil c['transaction_tracer']['transaction_threshold']
+    assert_equal 2.0, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+  end
+
+  def test_transaction_threshold__override
+    forced_start :transaction_tracer => { :transaction_threshold => 1}
+    assert_equal 1, c['transaction_tracer']['transaction_threshold']
+    assert_equal 1, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+  end
+  def test_merging_options
+    NewRelic::Control.send :public, :merge_options
+    @c.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
+    assert_equal 66, NewRelic::Control.instance['api_port']
+    assert_equal 2.0, NewRelic::Control.instance['transaction_tracer']['explain_threshold']
+    assert_equal 'raw', NewRelic::Control.instance['transaction_tracer']['record_sql']
+  end
+  private
+  def forced_start overrides = {}
+    NewRelic::Agent.manual_start overrides
+    # This is to force the agent to start again.
+    NewRelic::Agent.instance.stubs(:started?).returns(nil)
+    NewRelic::Agent.instance.start
+  end
+end

data/test/new_relic/data_serialization_test.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require 'new_relic/data_serialization'
+class NewRelic::DataSerializationTest < Test::Unit::TestCase
+  def test_read_and_write_from_file_read_only
+    file = './log/newrelic_agent_store.db'
+    File.open(file, 'w') do |f|
+      f.write(Marshal.dump('a happy string'))
+    end
+    NewRelic::DataSerialization.read_and_write_to_file do |data|
+      assert_equal('a happy string', data, "should pull the dumped item from the file")
+      nil # must explicitly return nil or the return value will be dumped
+    end
+    assert_equal(0, File.size(file), "Should not leave any data in the file")
+  end
+
+  def test_read_and_write_to_file_dumping_contents
+    file = './log/newrelic_agent_store.db'
+    expected_contents = Marshal.dump('a happy string')
+    NewRelic::DataSerialization.read_and_write_to_file do
+      'a happy string'
+    end
+    assert_equal(expected_contents, File.read(file), "should have dumped the contents")
+  end
+
+  def test_read_and_write_to_file_yields_old_data
+    file = './log/newrelic_agent_store.db'
+    expected_contents = 'a happy string'
+    File.open(file, 'w') do |f|
+      f.write(Marshal.dump(expected_contents))
+    end
+    contents = nil
+    NewRelic::DataSerialization.read_and_write_to_file do |old_data|
+      contents = old_data
+      'a happy string'
+    end
+    assert_equal(contents, expected_contents, "should have dumped the contents")
+  end
+
+  def test_read_and_write_to_file_round_trip
+    old_data = nil
+    NewRelic::DataSerialization.read_and_write_to_file do |data|
+      old_data = data
+      'a' * 30
+    end
+    NewRelic::DataSerialization.read_and_write_to_file do |data|
+      assert_equal('a'*30, data, "should be the same after serialization")
+    end
+  end
+
+  def test_should_send_data
+    NewRelic::DataSerialization.expects(:max_size).returns(20)
+    NewRelic::DataSerialization.read_and_write_to_file do
+      "a" * 30
+    end
+    assert(NewRelic::DataSerialization.should_send_data?, 'Should be over limit')
+  end
+
+  def test_should_send_data_disabled
+    NewRelic::Control.instance.expects(:disable_serialization?).returns(true)
+    assert(NewRelic::DataSerialization.should_send_data?, 'should send data when disabled')
+  end
+
+  def test_should_send_data_under_limit
+    NewRelic::DataSerialization.expects(:max_size).returns(50)
+    NewRelic::DataSerialization.read_and_write_to_file do
+      "a" * 5
+    end
+    assert(!NewRelic::DataSerialization.should_send_data?, 'Should be under the limit')
+  end
+end

data/test/new_relic/local_environment_test.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
+
+  def self.teardown
+    # To remove mock server instances from ObjectSpace
+    ObjectSpace.garbage_collect
+    super
+  end
+  class MockOptions
+    def fetch (*args)
+      1000
+    end
+  end
+  MOCK_OPTIONS = MockOptions.new
+
+#  def test_environment
+#    e = NewRelic::LocalEnvironment.new
+#    assert(nil == e.environment) # working around a bug in 1.9.1
+#    assert_match /test/i, e.dispatcher_instance_id
+#  end
+#  def test_no_webrick
+#    Object.const_set :OPTIONS, 'foo'
+#    e = NewRelic::LocalEnvironment.new
+#    assert(nil == e.environment) # working around a bug in 1.9.1
+#    assert_match /test/i, e.dispatcher_instance_id
+#    Object.class_eval { remove_const :OPTIONS }
+#  end
+
+  def test_passenger
+    class << self
+      module ::Passenger
+        const_set "AbstractServer", 0
+      end
+    end
+    e = NewRelic::LocalEnvironment.new
+    assert_equal :passenger, e.environment
+    assert_nil e.dispatcher_instance_id, "dispatcher instance id should be nil: #{e.dispatcher_instance_id}"
+
+    NewRelic::Control.instance.instance_eval do
+      @settings['app_name'] = 'myapp'
+    end
+
+    e = NewRelic::LocalEnvironment.new
+    assert_equal :passenger, e.environment
+    assert_nil e.dispatcher_instance_id
+
+    ::Passenger.class_eval { remove_const :AbstractServer }
+  end
+  def test_snapshot
+    e = NewRelic::LocalEnvironment.new
+    s = e.snapshot
+    assert_equal 0, s.size
+    e.gather_environment_info
+    s = e.snapshot
+    assert_match /1\.(8\.[67]|9\.\d)/, s.assoc('Ruby version').last, s.inspect
+    assert_equal 'test', s.assoc('Framework').last, s.inspect
+    # Make sure the processor count is determined on linux systems
+    if File.exists? '/proc/cpuinfo'
+      assert s.assoc('Processors').last.to_i > 0
+    end
+  end
+
+
+  def test_default_port
+    e = NewRelic::LocalEnvironment.new
+    assert_equal 3000, e.send(:default_port)
+    ARGV.push '--port=3121'
+    assert_equal '3121', e.send(:default_port)
+    ARGV.pop
+  end
+
+end

data/test/new_relic/metric_data_test.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require 'new_relic/metric_data'
+class NewRelic::MetricDataTest < Test::Unit::TestCase
+  def test_initialize_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md = NewRelic::MetricData.new(spec, stats, metric_id)
+    assert_equal spec, md.metric_spec
+    assert_equal stats, md.stats
+    assert_equal metric_id, md.metric_id
+  end
+
+  def test_eql_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')    
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    md2 = NewRelic::MetricData.new(spec, stats, metric_id)
+    assert(md1.eql?(md2), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(md2.eql?(md1), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")    
+  end
+
+  def test_eql_unequal_specs
+    
+    spec = mock('metric_spec')
+    other_spec = mock('other_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')    
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    md2 = NewRelic::MetricData.new(other_spec, stats, metric_id)
+    assert(!md1.eql?(md2), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")    
+  end
+  def test_eql_unequal_stats
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    other_stats = mock('other_stats')
+    metric_id = mock('metric_id')    
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    md2 = NewRelic::MetricData.new(spec, other_stats, metric_id)
+    assert(!md1.eql?(md2), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")    
+  end
+
+  def test_eql_unequal_metric_ids_dont_matter
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    other_metric_id = mock('other_metric_id')    
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    md2 = NewRelic::MetricData.new(spec, stats, other_metric_id)
+    assert(md1.eql?(md2), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")
+    assert(md2.eql?(md1), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")    
+  end
+
+  def test_original_spec_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')    
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+    assert_equal(spec, md1.metric_spec, "should return the metric spec for original spec when original spec is nil, but was #{md1.original_spec}")
+  end
+
+  def test_metric_spec_equal_should_not_set_original_spec_with_no_metric_spec
+    stats = mock('stats')
+    metric_id = mock('metric_id')    
+    md1 = NewRelic::MetricData.new(nil, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+    
+    new_spec = mock('new metric_spec')
+    assert_equal(new_spec, md1.metric_spec=(new_spec), "should return the new spec")
+
+    new_original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, new_original_spec, "should not set @original_spec  but was #{new_original_spec.inspect}")
+  end
+  
+  def test_metric_spec_equal_should_set_original_spec_with_existing_metric_spec
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')    
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+    
+    new_spec = mock('new metric_spec')
+    assert_equal(new_spec, md1.metric_spec=(new_spec), "should return the new spec")
+
+    new_original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(spec, new_original_spec, "should set @original_spec to the existing metric_spec  but was #{new_original_spec.inspect}")
+  end
+
+  def test_hash
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')    
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    assert((spec.hash ^ stats.hash) == md1.hash, "expected #{spec.hash ^ stats.hash} to equal #{md1.hash}")
+  end
+
+  def test_to_json_no_metric_id
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', ''), NewRelic::MethodTraceStats.new, nil)
+    json = md.to_json
+    assert(json.include?('"Custom/test/method"'), "should include the metric spec in the json")
+    assert(json.include?('"metric_id":null}'), "should have a null metric_id")
+  end
+
+  def test_to_json_with_metric_id
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', ''), NewRelic::MethodTraceStats.new, 12345)
+    assert_equal('{"metric_spec":null,"stats":{"total_exclusive_time":0.0,"min_call_time":0.0,"call_count":0,"sum_of_squares":0.0,"total_call_time":0.0,"max_call_time":0.0},"metric_id":12345}', md.to_json, "should not include the metric spec and should have a metric_id")
+  end
+
+  def test_to_s_with_metric_spec
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', ''), NewRelic::MethodTraceStats.new, 12345)
+    assert_equal('Custom/test/method(): [01/01/70 12:00AM UTC, 0.000s;  0 calls    0s]', md.to_s, "should not include the metric id and should include the metric spec")
+  end
+
+  def test_to_s_without_metric_spec
+    md = NewRelic::MetricData.new(nil, NewRelic::MethodTraceStats.new, 12345)
+    assert_equal('12345: [01/01/70 12:00AM UTC, 0.000s;  0 calls    0s]', md.to_s, "should include the metric id and not have a metric spec")
+  end
+end