ghazel-newrelic_rpm 3.1.0.1

data/test/new_relic/transaction_sample/summary_segment_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/transaction_sample/summary_segment'
+class NewRelic::TransactionSample::SummarySegmentTest < Test::Unit::TestCase
+  def test_summary_segment_creation
+    fake_segment = mock_segment
+    NewRelic::TransactionSample::SummarySegment.new(fake_segment)
+  end
+
+  def test_add_segments
+    fake_segment = mock_segment
+    ss = NewRelic::TransactionSample::SummarySegment.new(fake_segment)
+    other_fake_segment = mock_segment
+    # with the new summary segment
+    ss.expects(:add_called_segment).with(instance_of(NewRelic::TransactionSample::SummarySegment))
+    ss.add_segments([other_fake_segment])
+  end
+
+  private
+
+  @@seg_count = 0
+  def mock_segment
+    @@seg_count += 1
+    segment = mock('segment ' + @@seg_count.to_s)
+    segment.expects(:entry_timestamp).returns(Time.now)
+    segment.expects(:exit_timestamp).returns(Time.now)
+    segment.expects(:metric_name).returns('Custom/test/metric')
+    segment.expects(:called_segments).returns([])
+    segment
+  end
+end
+

data/test/new_relic/transaction_sample_subtest_test.rb

@@ -0,0 +1,56 @@
+class NewRelic::TransactionSample::SubTest < Test::Unit::TestCase
+  def setup
+    @t = NewRelic::TransactionSample.new
+
+    @t.params[:test] = "hi"
+
+    s1 = @t.create_segment(1.0, "controller")
+
+    @t.root_segment.add_called_segment(s1)
+
+    s2 = @t.create_segment(2.0, "AR1")
+
+    s2.params[:test] = "test"
+
+    s1.add_called_segment(s2)
+    s2.end_trace 3.0
+    s1.end_trace 4.0
+
+    s3 = @t.create_segment(4.0, "post_filter")
+    @t.root_segment.add_called_segment(s3)
+    s3.end_trace 6.0
+
+    s4 = @t.create_segment(6.0, "post_filter")
+    @t.root_segment.add_called_segment(s4)
+    s4.end_trace 7.0
+  end
+
+  def test_exclusive_duration
+    s1 = @t.root_segment.called_segments.first
+    assert_equal 3.0, s1.duration
+    assert_equal 2.0, s1.exclusive_duration
+  end
+
+  def test_count_the_segments
+    assert_equal 4, @t.count_segments
+  end
+
+  def test_truncate_long_samples
+    @t.truncate(2)
+    assert_equal 2, @t.count_segments
+
+    @t = NewRelic::TransactionSample.new
+
+    s1 = @t.create_segment(1.0, "controller")
+    @t.root_segment.add_called_segment(s1)
+
+    100.times do
+      s1.add_called_segment(@t.create_segment(1.0, "segment"))
+    end
+    assert_equal 101, @t.count_segments
+    @t.truncate(2)
+    assert_equal 2, @t.count_segments
+    assert_equal 101, @t.params[:segment_count]
+  end
+
+end

data/test/new_relic/transaction_sample_test.rb

@@ -0,0 +1,170 @@
+require File.expand_path('../../test_helper.rb', __FILE__)
+
+class NewRelic::TransactionSampleTest < Test::Unit::TestCase
+  include TransactionSampleTestHelper
+  ::SQL_STATEMENT = "SELECT * from sandwiches"
+
+  def setup
+    @connection_stub = Mocha::Mockery.instance.named_mock('connection')
+    @connection_stub.stubs(:execute).returns('QUERY RESULT')
+
+    NewRelic::TransactionSample.stubs(:get_connection).returns @connection_stub
+    @t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+  end
+
+  def test_be_recorded
+    assert_not_nil @t
+  end
+
+  def test_not_record_sql_when_record_sql_off
+    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+    s.each_segment do |segment|
+      assert_nil segment.params[:explanation]
+      assert_nil segment.params[:sql]
+    end
+  end
+
+  def test_record_raw_sql
+    s = @t.prepare_to_send(:explain_sql => 0.00000001, :record_sql => :raw)
+    got_one = false
+    s.each_segment do |segment|
+      fail if segment.params[:obfuscated_sql]
+      got_one = got_one || segment.params[:explanation] || segment.params[:sql]
+    end
+    assert got_one
+  end
+
+  def test_record_obfuscated_sql
+
+    s = @t.prepare_to_send(:explain_sql => 0.00000001, :record_sql => :obfuscated)
+
+    got_one = false
+    s.each_segment do |segment|
+      got_one = got_one || segment.params[:explanation] || segment.params[:sql]
+    end
+
+    assert got_one
+  end
+
+  def test_have_sql_rows_when_sql_is_recorded
+    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+
+    assert s.sql_segments.empty?
+    s.root_segment[:sql] = 'hello'
+    assert !s.sql_segments.empty?
+  end
+
+  def test_have_sql_rows_when_sql_is_obfuscated
+    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+
+    assert s.sql_segments.empty?
+    s.root_segment[:sql_obfuscated] = 'hello'
+    assert !s.sql_segments.empty?
+  end
+
+  def test_have_sql_rows_when_recording_non_sql_keys
+    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+
+    assert s.sql_segments.empty?
+    s.root_segment[:key] = 'hello'
+    assert !s.sql_segments.empty?
+  end
+
+  def test_catch_exceptions
+    @connection_stub.expects(:execute).raises
+    # the sql connection will throw
+    @t.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.00000001)
+  end
+
+  def test_have_explains
+
+    s = @t.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.00000001)
+
+    explain_count = 0
+    s.each_segment do |segment|
+      if segment.params[:explanation]
+        explanations = segment.params[:explanation]
+
+        explanations.each do |explanation|
+          assert_kind_of Array, explanation
+          assert_equal "QUERY RESULT", explanation.join('')
+          explain_count += 1
+        end
+      end
+    end
+    assert_equal 2, explain_count
+  end
+
+  def test_not_record_sql_without_record_sql_option
+    t = nil
+    NewRelic::Agent.disable_sql_recording do
+      t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    end
+
+    s = t.prepare_to_send(:explain_sql => 0.00000001)
+
+    s.each_segment do |segment|
+      assert_nil segment.params[:explanation]
+      assert_nil segment.params[:sql]
+    end
+  end
+
+  def test_not_record_transactions
+    NewRelic::Agent.disable_transaction_tracing do
+      t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+      assert t.nil?
+    end
+  end
+
+  def test_path_string
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    fake_segment = mock('segment')
+    fake_segment.expects(:path_string).returns('a path string')
+    s.instance_eval do
+      @root_segment = fake_segment
+    end
+
+    assert_equal('a path string', s.path_string)
+  end
+
+  def test_params_equals
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s.params = {:params => 'hash' }
+    assert_equal({:params => 'hash'}, s.params, "should have the specified hash, but instead was #{s.params}")
+  end
+
+  class Hat
+    # just here to mess with the to_s logic in transaction samples
+  end
+
+  def test_to_s_with_bad_object
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s.params[:fake] = Hat.new
+    assert_raise(RuntimeError) do
+      s.to_s
+    end
+  end
+  
+  def test_to_s_includes_keys
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s.params[:fake_key] = 'a fake param'
+    assert(s.to_s.include?('fake_key'), "should include 'fake_key' but instead was (#{s.to_s})")
+    assert(s.to_s.include?('a fake param'), "should include 'a fake param' but instead was (#{s.to_s})")
+  end
+
+  def test_find_segment
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    fake_segment = mock('segment')
+    fake_segment.expects(:find_segment).with(1).returns('a segment')
+    s.instance_eval do
+      @root_segment = fake_segment
+    end
+
+    assert_equal('a segment', s.find_segment(1))
+  end
+
+  def test_timestamp
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    assert(s.timestamp.instance_of?(Float), "s.timestamp should be a Float, but is #{s.timestamp.class.inspect}")
+  end
+end

data/test/new_relic/version_number_test.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+class NewRelic::VersionNumberTest < Test::Unit::TestCase
+
+  def test_comparison__first
+    versions = %w[1.0.0 0.1.0 0.0.1 10.0.1 1.10.0].map {|s| NewRelic::VersionNumber.new s }
+    assert_equal %w[0.0.1 0.1.0 1.0.0 1.10.0 10.0.1], versions.sort.map(&:to_s)
+    v0 = NewRelic::VersionNumber.new '1.2.3'
+    v1 = NewRelic::VersionNumber.new '1.2.2'
+    v3 = NewRelic::VersionNumber.new '1.2.2'
+    assert v0 > v1
+    assert v1 == v1
+    assert v1 == v3
+  end
+  def test_comparison__second
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '2.2.2'
+    v3 = NewRelic::VersionNumber.new '1.1.2'
+    assert v0 < v1
+    assert v1 > v3
+    assert v3 < v0
+  end
+  def test_bug
+    v0 = NewRelic::VersionNumber.new '2.8.999'
+    v1 = NewRelic::VersionNumber.new '2.9.10'
+    assert v1 > v0
+    assert v0 <= v1
+  end
+  def test_long_version
+    v0 = NewRelic::VersionNumber.new '1.2.3.4'
+    v1 = NewRelic::VersionNumber.new '1.2.3.3'
+    v3 = NewRelic::VersionNumber.new '1.3'
+    assert v0 > v1
+    assert v0 < '1.2.3.5'
+    assert ! (v0 < '1.2.3.4')
+    assert v3 > v0
+  end
+  def test_sort
+    values = %w[1.1.1
+                1.1.99
+                1.1.999
+                2.0.6
+                2.6.5
+                2.7
+                2.7.1
+                2.7.2
+                2.7.2.0
+                3
+                999]
+    assert_equal values, values.map{|v| NewRelic::VersionNumber.new v}.sort.map(&:to_s)
+  end
+  def test_prerelease
+    v0 = NewRelic::VersionNumber.new '1.2.0.beta'
+    assert_equal [1,2,0,'beta'], v0.parts
+    assert v0 > '1.1.9.0'
+    assert v0 > '1.1.9.alpha'
+    assert v0 > '1.2.0.alpha'
+    assert v0 == '1.2.0.beta'
+    assert v0 < '1.2.1'
+    assert v0 < '1.2.0'
+    assert v0 < '1.2.0.c'
+    assert v0 < '1.2.0.0'
+
+  end
+  def test_compare_string
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '2.2.2'
+    v3 = NewRelic::VersionNumber.new '1.1.2'
+    assert v0 < '2.2.2'
+    assert v1 > '1.1.2'
+    assert v3 < '1.2.0'
+    assert v0 == '1.2.0'
+  end
+  def test_4_numbers
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '1.2.0.1'
+    v2 = NewRelic::VersionNumber.new '1.2.1.0'
+    v3 = NewRelic::VersionNumber.new '1.2.1.1'
+    assert v0 < v1
+    assert v1 < v2
+    assert v2 < v3
+    assert v0 < v3
+    assert v0 < '1.2.0.1'
+    assert v0 > '1.1.0.1'
+  end
+  def test_string
+    assert_equal '1.2.0', NewRelic::VersionNumber.new('1.2.0').to_s
+    assert_equal '1.2', NewRelic::VersionNumber.new('1.2').to_s
+  end
+end

data/test/test_contexts.rb

@@ -0,0 +1,29 @@
+
+module TestContexts
+  def with_running_agent
+
+    context 'with running agent' do # this is needed for the nested setups
+
+      setup do
+        @log_data = StringIO.new
+        @log = Logger.new(@log_data)
+        NewRelic::Agent.manual_start :log => @log
+        @agent = NewRelic::Agent.instance
+        @agent.transaction_sampler.send :clear_builder
+        @agent.transaction_sampler.reset!
+        @agent.stats_engine.clear_stats
+      end
+
+      yield
+
+      def teardown
+        super
+        NewRelic::Agent.shutdown
+        @log_data.reset
+        NewRelic::Control.instance['dispatcher']=nil
+        NewRelic::Control.instance['dispatcher_instance_id']=nil
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,144 @@
+module NewRelic; TEST = true; end unless defined? NewRelic::TEST
+ENV['RAILS_ENV'] = 'test'
+NEWRELIC_PLUGIN_DIR = File.expand_path(File.join(File.dirname(__FILE__),".."))
+$LOAD_PATH << '.'
+$LOAD_PATH << '../../..'
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"test")
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"ui/helpers")
+$LOAD_PATH.uniq!
+
+require 'rubygems'
+# We can speed things up in tests that don't need to load rails.
+# You can also run the tests in a mode without rails.  Many tests
+# will be skipped.
+
+begin
+  require 'config/environment'
+  begin
+    require 'test_help'
+  rescue LoadError
+    # ignore load problems on test help - it doesn't exist in rails 3
+  end
+
+rescue LoadError
+  puts "Unable to load Rails for New Relic tests"
+  raise
+end
+require 'newrelic_rpm'
+
+require 'test/unit'
+require 'shoulda'
+require 'test_contexts'
+require 'mocha'
+require 'mocha/integration/test_unit'
+require 'mocha/integration/test_unit/assertion_counter'
+
+class Test::Unit::TestCase
+  include Mocha::API
+
+  # FIXME delete this trick when we stop supporting rails2.0.x
+  if ENV['BRANCH'] != 'rails20'
+    # a hack because rails2.0.2 does not like double teardowns
+    def teardown
+      mocha_teardown
+    end
+  end
+end
+
+def assert_between(floor, ceiling, value, message="expected #{floor} <= #{value} <= #{ceiling}")
+  assert((floor <= value && value <= ceiling), message)
+end
+
+def check_metric_time(metric, value, delta)
+  time = NewRelic::Agent.get_stats(metric).total_call_time
+  assert_between((value - delta), (value + delta), time)
+end
+
+def check_metric_count(metric, value)
+  count = NewRelic::Agent.get_stats(metric).call_count
+  assert_equal(value, count, "should have the correct number of calls")
+end
+
+def check_unscoped_metric_count(metric, value)
+  count = NewRelic::Agent.get_stats_unscoped(metric).call_count
+  assert_equal(value, count, "should have the correct number of calls")
+end
+
+def generate_unscoped_metric_counts(*metrics)
+  metrics.inject({}) do |sum, metric|
+    sum[metric] = NewRelic::Agent.get_stats_no_scope(metric).call_count
+    sum
+  end
+end
+
+def generate_metric_counts(*metrics)
+  metrics.inject({}) do |sum, metric|
+    sum[metric] = NewRelic::Agent.get_stats(metric).call_count
+    sum
+  end
+end
+
+def assert_does_not_call_metrics(*metrics)
+  first_metrics = generate_metric_counts(*metrics)
+  yield
+  last_metrics = generate_metric_counts(*metrics)
+  assert_equal first_metrics, last_metrics, "should not have changed these metrics"
+end
+
+def assert_calls_metrics(*metrics)
+  first_metrics = generate_metric_counts(*metrics)
+  yield
+  last_metrics = generate_metric_counts(*metrics)
+  assert_not_equal first_metrics, last_metrics, "should have changed these metrics"
+end
+
+def assert_calls_unscoped_metrics(*metrics)
+  first_metrics = generate_unscoped_metric_counts(*metrics)
+  yield
+  last_metrics = generate_unscoped_metric_counts(*metrics)
+  assert_not_equal first_metrics, last_metrics, "should have changed these metrics"
+end
+
+
+def compare_metrics(expected, actual)
+  actual.delete('GC/cumulative') # in case we are in REE
+  assert_equal(expected.to_a.sort, actual.to_a.sort, "extra: #{(actual - expected).to_a.inspect}; missing: #{(expected - actual).to_a.inspect}")
+end
+
+module TransactionSampleTestHelper
+  def make_sql_transaction(*sql)
+    sampler = NewRelic::Agent::TransactionSampler.new
+    sampler.notice_first_scope_push Time.now.to_f
+    sampler.notice_transaction '/path', nil, :jim => "cool"
+    sampler.notice_push_scope "a"
+
+    sampler.notice_transaction '/path/2', nil, :jim => "cool"
+
+    sql.each {|sql_statement| sampler.notice_sql(sql_statement, {:adapter => "test"}, 0 ) }
+
+    sleep 0.02
+    yield if block_given?
+    sampler.notice_pop_scope "a"
+    sampler.notice_scope_empty
+
+    sampler.samples[0]
+  end
+
+  def run_sample_trace_on(sampler, path='/path')
+    sampler.notice_first_scope_push Time.now.to_f
+    sampler.notice_transaction path, path, {}
+    sampler.notice_push_scope "Controller/sandwiches/index"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", nil, 0)
+    sampler.notice_push_scope "ab"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'white'", nil, 0)
+    yield sampler if block_given?
+    sampler.notice_pop_scope "ab"
+    sampler.notice_push_scope "lew"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", nil, 0)
+    sampler.notice_pop_scope "lew"
+    sampler.notice_pop_scope "Controller/sandwiches/index"
+    sampler.notice_scope_empty
+    sampler.samples[0]
+  end
+
+end