newrelic_rpm 3.0.1 → 3.1.0.beta1

data/test/new_relic/agent/instrumentation/rack_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+require 'new_relic/agent/instrumentation/rack'
+
+class MinimalRackApp
+  def initialize(return_value)
+    @return_value = return_value
+  end
+
+  def call(env)
+    @return_value
+  end
+
+  include NewRelic::Agent::Instrumentation::Rack
+end
+
+class NewRelic::Agent::Instrumentation::RackTest < Test::Unit::TestCase
+
+  def test_basic_rack_app
+    # should return what we send in, even when instrumented
+    x = MinimalRackApp.new([200, {}, ["whee"]])
+    assert_equal [200, {}, ["whee"]], x.call({})
+  end
+
+  def test_basic_rack_app_404
+    x = MinimalRackApp.new([404, {}, ["whee"]])
+    assert_equal [404, {}, ["whee"]], x.call({})
+  end
+
+  def test_basic_rack_app_ignores_404
+    NewRelic::Agent::Instrumentation::MetricFrame.expects(:abort_transaction!)
+    x = MinimalRackApp.new([404, {}, ["whee"]])
+    assert_equal [404, {}, ["whee"]], x.call({})
+  end
+end
+

data/test/new_relic/agent/instrumentation/task_instrumentation_test.rb

@@ -155,7 +155,6 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
   private
 
   def run_task_inner(n)
-    sleep 0.1
     return if n == 0
     assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
     run_task_inner(n-1)

data/test/new_relic/agent/method_tracer_test.rb

@@ -89,7 +89,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     metric = "hello"
     t1 = Time.now
     self.class.trace_execution_scoped metric do
-      sleep 1
+      sleep 0.05
       assert metric == @stats_engine.peek_scope.name
     end
     elapsed = Time.now - t1
@@ -103,7 +103,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     metric = "hello"
     t1 = Time.now
     self.class.trace_method_execution metric, true, true, true do
-      sleep 1
+      sleep 0.05
       assert metric == @stats_engine.peek_scope.name
     end
     elapsed = Time.now - t1
@@ -175,9 +175,9 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
 
     method_c1
 
-    assert_not_nil @stats_engine.lookup_stat("c1")
-    assert_nil @stats_engine.lookup_stat("c2")
-    assert_not_nil @stats_engine.lookup_stat("c3")
+    assert_not_nil @stats_engine.lookup_stats("c1")
+    assert_nil @stats_engine.lookup_stats("c2")
+    assert_not_nil @stats_engine.lookup_stats("c3")
 
     assert_not_nil @scope_listener.scope["c2"]
   end
@@ -341,13 +341,13 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   end
 
   def check_time(t1, t2)
-    assert_in_delta t2, t1, 0.02
+    assert_in_delta t2, t1, 0.05
   end
 
   # =======================================================
   # test methods to be traced
   def method_to_be_traced(x, y, z, is_traced, expected_metric)
-    sleep 0.1
+    sleep 0.01
     assert x == 1
     assert y == 2
     assert z == 3
@@ -360,7 +360,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   end
 
   def method_with_block(x, y, z, is_traced, expected_metric, &block)
-    sleep 0.1
+    sleep 0.01
     assert x == 1
     assert y == 2
     assert z == 3

data/test/new_relic/agent/sampler_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+class NewRelic::Agent::SamplerTest < Test::Unit::TestCase
+  require 'new_relic/agent/sampler'
+
+  def test_inherited_should_append_subclasses_to_sampler_classes
+    test_class = Class.new(NewRelic::Agent::Sampler)
+    sampler_classes = NewRelic::Agent::Sampler.instance_eval { @sampler_classes }
+    assert(sampler_classes.include?(test_class), "Sampler classes (#{@sampler_classes.inspect}) does not include #{test_class.inspect}")
+    # cleanup the sampler created above
+    NewRelic::Agent::Sampler.instance_eval { @sampler_classes.delete(test_class) }
+  end
+
+  def test_sampler_classes_should_be_an_array
+    sampler_classes = NewRelic::Agent::Sampler.instance_variable_get('@sampler_classes')
+    assert(sampler_classes.is_a?(Array), 'Sampler classes should be saved as an array')
+    assert(sampler_classes.include?(NewRelic::Agent::Samplers::CpuSampler), 'Sampler classes should include the CPU sampler')
+  end
+
+end

data/test/new_relic/agent/shim_agent_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+module NewRelic
+  module Agent
+    class ShimAgentTest < Test::Unit::TestCase
+
+      def setup
+        super
+        @agent = NewRelic::Agent::ShimAgent.new
+      end
+
+      def test_serialize
+        assert_equal(nil, @agent.serialize, "should return nil when shut down")
+      end
+
+      def test_merge_data_from
+        assert_equal(nil, @agent.merge_data_from(mock('metric data')))
+      end
+    end
+  end
+end

data/test/new_relic/agent/stats_engine/metric_stats/harvest_test.rb

@@ -0,0 +1,150 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
+require 'new_relic/agent/stats_engine/metric_stats'
+class NewRelic::Agent::StatsEngine::MetricStats::HarvestTest < Test::Unit::TestCase
+  include NewRelic::Agent::StatsEngine::MetricStats::Harvest
+
+  attr_accessor :stats_hash
+  def test_merge_stats_trivial
+    self.stats_hash = {}
+    merge_stats({}, {})
+  end
+
+  def test_merge_stats_with_nil_stats
+    metric_ids = mock('metric ids')
+    mock_stats_hash = mock('stats_hash')
+    mock_spec = mock('spec')
+    mock_stats = mock('stats')
+    mock_stats_hash.expects(:each).yields(mock_spec, mock_stats)
+    self.stats_hash = mock_stats_hash
+
+    self.expects(:coerce_to_metric_spec).with(mock_spec).returns(mock_spec)
+    self.expects(:clone_and_reset_stats).with(mock_spec, mock_stats).returns(mock_stats)
+    self.expects(:merge_old_data!).with(mock_spec, mock_stats, {})
+    metric_ids.expects(:[]).with(mock_spec).returns('an id')
+    self.expects(:add_data_to_send_unless_empty).with({}, mock_stats, mock_spec, 'an id')
+
+
+    merge_stats({}, metric_ids)
+  end
+
+
+  def test_get_stats_hash_from_hash
+    assert_equal({}, get_stats_hash_from({}))
+  end
+
+  def test_get_stats_hash_from_engine
+    assert_equal({}, get_stats_hash_from(NewRelic::Agent::StatsEngine.new))
+  end
+
+  def test_coerce_to_metric_spec_metric_spec
+    assert_equal NewRelic::MetricSpec.new, coerce_to_metric_spec(NewRelic::MetricSpec.new)
+  end
+
+  def test_coerce_to_metric_spec_string
+    assert_equal NewRelic::MetricSpec.new('foo'), coerce_to_metric_spec('foo')
+  end
+
+  def test_clone_and_reset_stats_nil
+    spec = NewRelic::MetricSpec.new('foo', 'bar')
+    stats = nil
+    begin
+      clone_and_reset_stats(spec, stats)
+    rescue RuntimeError => e
+      assert_equal("Nil stats for foo (bar)", e.message)
+    end
+  end
+
+  def test_clone_and_reset_stats_present
+    # spec is only used for debug output
+    spec = nil
+    stats = mock('stats')
+    stats_clone = mock('stats_clone')
+    stats.expects(:clone).returns(stats_clone)
+    stats.expects(:reset)
+    # should return a clone
+    assert_equal stats_clone, clone_and_reset_stats(spec, stats)
+  end
+
+  def test_merge_old_data_present
+    metric_spec = mock('metric_spec')
+    stats = mock('stats obj')
+    stats.expects(:merge!).with('some stats')
+    old_data = mock('old data')
+    old_data.expects(:stats).returns('some stats')
+    old_data_hash = {metric_spec => old_data}
+    merge_old_data!(metric_spec, stats, old_data_hash)
+  end
+
+  def test_merge_old_data_nil
+    metric_spec = mock('metric_spec')
+    stats = mock('stats') # doesn't matter
+    old_data_hash = {metric_spec => nil}
+    merge_old_data!(metric_spec, stats, old_data_hash)
+  end
+
+  def test_add_data_to_send_unless_empty_when_is_empty
+    stats = mock('stats')
+    stats.expects(:is_reset?).returns(true)
+    assert_equal nil, add_data_to_send_unless_empty(nil, stats, nil, nil)
+  end
+
+  def test_add_data_to_send_unless_empty_main
+    data = mock('data hash')
+    stats = mock('stats')
+    stats.expects(:is_reset?).returns(false)
+    metric_spec = mock('spec')
+
+    NewRelic::MetricData.expects(:new).with(metric_spec, stats, nil).returns('metric data')
+    data.expects(:[]=).with(metric_spec, 'metric data')
+    add_data_to_send_unless_empty(data, stats, metric_spec, nil)
+  end
+
+  def test_add_data_to_send_unless_empty_with_id
+    data = mock('data hash')
+    stats = mock('stats')
+    stats.expects(:is_reset?).returns(false)
+    metric_spec = mock('spec')
+    id = mock('id')
+
+    NewRelic::MetricData.expects(:new).with(nil, stats, id).returns('metric data')
+    data.expects(:[]=).with(metric_spec, 'metric data')
+    assert_equal 'metric data', add_data_to_send_unless_empty(data, stats, metric_spec, id)
+  end
+
+  def test_merge_data_basic
+    mock_stats_hash = mock('stats hash')
+    self.stats_hash = mock_stats_hash
+    merge_data({})
+  end
+
+  def test_merge_data_new_and_old_data
+    stats = NewRelic::MethodTraceStats.new
+    stats.record_data_point(1.0)
+    new_stats = NewRelic::MethodTraceStats.new
+    new_stats.record_data_point(2.0)
+    self.expects(:lookup_stats).with('Custom/test/method', '').returns(new_stats)
+    assert_equal(2.0, new_stats.total_call_time)
+
+    metric_spec = NewRelic::MetricSpec.new('Custom/test/method')
+    mock_stats_hash = mock('stats_hash')
+    self.stats_hash = mock_stats_hash
+    merge_data({metric_spec => NewRelic::MetricData.new(metric_spec, stats, nil)})
+    assert_equal(3.0, new_stats.total_call_time)
+  end
+
+  def test_merge_data_old_data
+    stats = NewRelic::MethodTraceStats.new
+    stats.record_data_point(1.0)
+    self.expects(:lookup_stats).returns(nil)
+
+    metric_spec = NewRelic::MetricSpec.new('Custom/test/method')
+    mock_stats_hash = mock('stats_hash')
+    mock_stats_hash.expects(:[]=).with(metric_spec, stats)
+    self.stats_hash = mock_stats_hash
+    merge_data({metric_spec => NewRelic::MetricData.new(metric_spec, stats, nil)})
+  end
+
+end
+
+
+

data/test/new_relic/agent/stats_engine/metric_stats_test.rb

@@ -13,6 +13,7 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     @engine.harvest_timeslice_data({},{})
     super
   end
+
   def test_get_no_scope
     s1 = @engine.get_stats "a"
     s2 = @engine.get_stats "a"

data/test/new_relic/agent/stats_engine/samplers_test.rb

@@ -35,11 +35,12 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
 
   def test_cpu
     s = NewRelic::Agent::Samplers::CpuSampler.new
-    # need to sleep because if you go to fast it will skip the points
+    # need to set this instance value to prevent it skipping a 'too
+    # fast' poll time
     s.stats_engine = @stats_engine
-    sleep 2
+    s.instance_eval { @last_time = Time.now - 1.1 }
     s.poll
-    sleep 2
+    s.instance_eval { @last_time = Time.now - 1.1 }
     s.poll
     assert_equal 2, s.systemtime_stats.call_count
     assert_equal 2, s.usertime_stats.call_count

data/test/new_relic/agent/{stats_engine/stats_engine_test.rb → stats_engine_test.rb}

@@ -1,7 +1,7 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..', 'test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..', 'test_helper'))
 
 
-class NewRelic::Agent::StatsEngine::TransactionsTest < Test::Unit::TestCase
+class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
   def setup
     NewRelic::Agent.manual_start
     @engine = NewRelic::Agent::StatsEngine.new
@@ -93,27 +93,27 @@ class NewRelic::Agent::StatsEngine::TransactionsTest < Test::Unit::TestCase
     t1 = Time.now
 
     expected1 = @engine.push_scope "a"
-    sleep 0.1
+    sleep 0.001
     t2 = Time.now
 
     expected2 = @engine.push_scope "b"
-    sleep 0.2
+    sleep 0.002
     t3 = Time.now
 
     expected = @engine.push_scope "c"
-    sleep 0.3
+    sleep 0.003
     scope = @engine.pop_scope expected, Time.now - t3
 
     t4 = Time.now
 
     check_time_approximate 0, scope.children_time
-    check_time_approximate 0.3, @engine.peek_scope.children_time
+    check_time_approximate 0.003, @engine.peek_scope.children_time
 
-    sleep 0.1
+    sleep 0.001
     t5 = Time.now
 
     expected = @engine.push_scope "d"
-    sleep 0.2
+    sleep 0.002
     scope = @engine.pop_scope expected, Time.now - t5
 
     t6 = Time.now

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -743,7 +743,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert((slowest.duration >= 0.09), "expected sample duration >= 0.09, but was: #{slowest.duration.inspect}")
     # this assert is here to make sure the test remains valid
     assert((slowest.duration <= 0.15), "expected sample duration <= 0.15, but was: #{slowest.duration.inspect}")
-    
+
 
     run_sample_trace { sleep 0.0001 }
     not_as_slow = @sampler.harvest(slowest, 0)[0]

data/test/new_relic/agent/worker_loop_test.rb

@@ -23,7 +23,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     # This shows how the tasks stay aligned with the period and don't drift.
     count = 0
     start = Time.now
-    @worker_loop.run(0.2) do
+    @worker_loop.run(0.002) do
       count +=1
       if count == 10
         @worker_loop.stop
@@ -31,7 +31,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
       end
     end
     elapsed = Time.now - start
-    assert_in_delta 1.9, elapsed, 0.2
+    assert_in_delta 0.019, elapsed, 0.02
   end
   def test_task_error__standard
     @logger.expects(:debug)

data/test/new_relic/control/class_methods_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/control/class_methods'
+
+class BaseClassMethods
+  # stub class to enable testing of the module
+  include NewRelic::Control::ClassMethods
+end
+
+class NewRelic::Control::ClassMethodsTest < Test::Unit::TestCase
+  def setup
+    @base = ::BaseClassMethods.new
+    super
+  end
+
+  def test_instance
+    assert_equal(nil, @base.instance_variable_get('@instance'), 'instance should start out nil')
+    @base.expects(:new_instance).returns('a new instance')
+    assert_equal('a new instance', @base.instance, "should return the result from the #new_instance call")
+  end
+
+  def test_new_instance_non_test
+    local_env = mock('local env')
+    @base.expects(:local_env).returns(local_env).at_least_once
+    local_env.expects(:framework).returns('nontest').twice
+    mock_klass = mock('klass')
+    mock_klass.expects(:new).with(local_env)
+    @base.expects(:load_framework_class).with('nontest').returns(mock_klass)
+    @base.new_instance
+  end
+  
+  def test_new_instance_test_framework
+    local_env = mock('local env')
+    local_env.expects(:framework).returns(:test)
+    @base.expects(:local_env).returns(local_env)
+    @base.expects(:load_test_framework)
+    @base.new_instance
+  end
+
+  def test_load_test_framework
+    local_env = mock('local env')
+    # a loose requirement here because the tests will *all* break if
+    # this does not work.
+    NewRelic::Control::Frameworks::Test.expects(:new).with(local_env, instance_of(String))
+    @base.expects(:local_env).returns(local_env)
+    @base.load_test_framework
+  end
+
+  def test_load_framework_class_existing
+    %w[rails rails3 sinatra ruby merb external].each do |type|
+      @base.load_framework_class(type)
+    end
+  end
+  
+  def test_load_framework_class_missing
+    # this is used to allow other people to insert frameworks without
+    # having the file in our agent, i.e. define your own
+    # NewRelic::Control::Framework::FooBar
+    assert_raise(NameError) do
+      @base.load_framework_class('missing')
+    end
+  end
+end