sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/rack/error_collector_test.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..',
+                                   'test_helper'))
+require 'rack/test'
+require 'new_relic/rack/error_collector'
+
+module NewRelic::Rack
+  class ErrorCollectorTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    class TestApp
+      def call(env)
+        if env['PATH_INFO'] == '/ignored'
+          env['action_dispatch.request.parameters'] = {
+            'controller' => 'test_ignore',
+            'action'     => 'ignored'
+          }
+        end
+        raise 'unhandled error'
+      end
+    end
+
+    def app
+      NewRelic::Rack::ErrorCollector.new(TestApp.new)
+    end
+
+    def setup
+      NewRelic::Agent.reset_config
+      NewRelic::Agent.manual_start
+      NewRelic::Agent.instance.error_collector
+      NewRelic::Agent.instance.error_collector.errors = []
+
+      # sanity checks
+      assert NewRelic::Agent.instance.error_collector.enabled?
+      NewRelic::Agent.instance.error_collector \
+        .instance_variable_set(:@ignore_filter, nil)
+      assert !NewRelic::Agent.instance.error_collector.ignore_error_filter
+    end
+
+    def test_notice_and_reraise_errors
+      assert_raise RuntimeError do
+        get '/'
+      end
+
+      assert_equal('unhandled error',
+                   NewRelic::Agent.instance.error_collector.errors[0].message)
+    end
+
+    def test_ignore_filtered_errors
+      NewRelic::Agent.instance.error_collector.ignore_error_filter do |error|
+        !error.kind_of?(RuntimeError)
+      end
+
+      assert_raise RuntimeError do
+        get '/'
+      end
+
+      assert(NewRelic::Agent.instance.error_collector.errors.empty?,
+             'noticed an error that should have been ignored')
+    end
+
+    def test_ignore_errors_from_ignored_actions
+      assert_raise RuntimeError do
+        get '/ignored'
+      end
+
+      assert(NewRelic::Agent.instance.error_collector.errors.empty?,
+             'noticed an error that should have been ignored')
+    end
+
+    def test_handles_parameter_parsing_exceptions
+      bad_request = stub(:env => {}, :path => '/', :referer => '')
+      bad_request.stubs(:params).raises(TypeError, "can't convert nil into Hash")
+      Rack::Request.stubs(:new).returns(bad_request)
+
+      assert_raise RuntimeError do
+        get '/'
+      end
+
+      assert_equal('unhandled error',
+                   NewRelic::Agent.instance.error_collector.errors[0].message)
+      assert_match(/failed to capture request parameters/i,
+                   NewRelic::Agent.instance.error_collector.errors[0].params[:request_params]['error'])
+    end
+
+  end
+end
+
+class TestIgnoreController
+  @do_not_trace = { :only => :ignored }
+end

data/test/new_relic/transaction_analysis/segment_summary_test.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','test_helper'))
+require 'new_relic/transaction_analysis/segment_summary'
+class NewRelic::TransactionAnalysis::SegmentSummaryTest < Test::Unit::TestCase
+
+  def setup
+    @sample = mock('sample')
+    @ss = NewRelic::TransactionAnalysis::SegmentSummary.new('Controller/foo', @sample)
+  end
+
+  # these are mostly stub tests just making sure that the API doesn't
+  # change if anyone ever needs to modify it.
+
+  def test_insert
+    segment = mock('segment')
+    segment.expects(:metric_name).returns('Controller/foo')
+    segment.expects(:duration).returns(0.1)
+    segment.expects(:exclusive_duration).returns(0.1)
+    @ss << segment
+    assert_equal 0.1, @ss.total_time
+    assert_equal 0.1, @ss.exclusive_time
+    assert_equal 1, @ss.call_count
+  end
+
+  def test_insert_error
+    segment = mock('segment')
+    segment.expects(:metric_name).returns('Controller/bar').twice
+    assert_raise(ArgumentError) do
+      @ss << segment
+    end
+  end
+
+  def test_average_time
+    @ss.total_time = 0.1
+    @ss.call_count = 2
+    assert_equal 0.05, @ss.average_time
+  end
+
+  def test_average_exclusive_time
+    @ss.exclusive_time = 0.1
+    @ss.call_count = 2
+    assert_equal 0.05, @ss.average_exclusive_time
+  end
+
+  def test_exclusive_time_percentage_nil
+    @ss.exclusive_time = nil
+    assert_equal 0, @ss.exclusive_time_percentage
+  end
+
+  def test_exclusive_time_percentage
+    @ss.exclusive_time = 0.05
+    @sample.expects(:duration).returns(0.1).times(3)
+    assert_equal 0.5, @ss.exclusive_time_percentage
+  end
+
+  def test_total_time_percentage_nil
+    @ss.total_time = nil
+    assert_equal 0, @ss.total_time_percentage
+  end
+
+  def test_total_time_percentage
+    @ss.total_time = 0.05
+    @sample.expects(:duration).returns(0.1).times(3)
+    assert_equal 0.5, @ss.total_time_percentage
+  end
+
+  def test_nesting_total_time
+    segment = mock('segment')
+    segment.expects(:metric_name).twice.returns('Controller/foo')
+    segment.expects(:duration).returns(0.1)
+    segment.expects(:exclusive_duration).returns(0)
+    @ss << segment
+    segment.expects(:exclusive_duration).returns(0.1)
+    @ss.current_nest_count += 1
+    @ss << segment
+    assert_equal 0.1, @ss.total_time
+    assert_equal 0.1, @ss.exclusive_time
+    assert_equal 2, @ss.call_count
+  end
+
+  def test_ui_name_default
+    @ss.metric_name = 'Remainder'
+    assert_equal 'Remainder', @ss.ui_name
+  end
+
+  def test_ui_name_lookup
+    mocked_object = mock('metric parser obj')
+    mocked_object.expects(:developer_name).returns('Developer Name')
+    NewRelic::MetricParser::MetricParser.expects(:parse).with('Controller/foo').returns(mocked_object)
+    assert_equal 'Developer Name', @ss.ui_name
+  end
+end

data/test/new_relic/transaction_analysis_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require 'new_relic/transaction_analysis'
+class NewRelic::TransactionAnalysisTest < Test::Unit::TestCase
+  include NewRelic::TransactionAnalysis
+
+  # these are mostly stub tests just making sure that the API doesn't
+  # change if anyone ever needs to modify it.
+
+  def test_database_time
+    self.expects(:time_percentage).with(/^Database\/.*/)
+    database_time
+  end
+
+  def test_render_time
+    self.expects(:time_percentage).with(/^View\/.*/)
+    render_time
+  end
+
+  def test_breakdown_data_default
+    root_segment = mock('root_segment')
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    root_segment.stubs(:to_a).returns([root_segment])
+    other_segment = mock('other_segment')
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    other_segment.stubs(:to_a).returns([other_segment])
+    other_segment.expects(:metric_name).twice.returns('Controller/foo')
+    other_segment.expects(:duration).returns(0.1)
+    other_segment.expects(:exclusive_duration).returns(0.1)
+    self.expects(:each_segment_with_nest_tracking).multiple_yields(root_segment, other_segment)
+    self.expects(:root_segment).twice.returns(root_segment)
+    self.expects(:duration).returns(0.1)
+    data = breakdown_data
+    assert_equal 'Controller/foo', data[0].metric_name
+  end
+
+  # kind of a hairy test, we're making sure that the data is truncated
+  # to one element by the limit
+  def test_breakdown_data_limit_one
+    root_segment = mock('root_segment')
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    root_segment.stubs(:to_a).returns([root_segment])
+    other_segment = mock('other_segment')
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    other_segment.stubs(:to_a).returns([other_segment])
+    other_segment.expects(:metric_name).twice.returns('Controller/foo')
+    other_segment.expects(:duration).returns(0.1)
+    other_segment.expects(:exclusive_duration).returns(0.1)
+    yet_another = mock('another segment')
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    yet_another.stubs(:to_a).returns([yet_another])
+    yet_another.expects(:metric_name).twice.returns('Controller/bar')
+    yet_another.expects(:duration).returns(0.2)
+    yet_another.expects(:exclusive_duration).returns(0.2)
+    self.expects(:each_segment_with_nest_tracking).multiple_yields(root_segment, other_segment, yet_another)
+    self.expects(:root_segment).times(3).returns(root_segment)
+    self.expects(:duration).returns(0.1)
+    data = breakdown_data(1)
+    assert_equal 1, data.size
+    assert_equal 'Controller/bar', data[0].metric_name
+  end
+
+  def test_breakdown_data_remainder
+    root_segment = mock('root_segment')
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    root_segment.stubs(:to_a).returns([root_segment])
+    other_segment = mock('other_segment')
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    other_segment.stubs(:to_a).returns([other_segment])
+    other_segment.expects(:metric_name).twice.returns('Controller/foo')
+    other_segment.expects(:duration).returns(0.1)
+    other_segment.expects(:exclusive_duration).returns(0.1)
+    self.expects(:each_segment_with_nest_tracking).multiple_yields(root_segment, other_segment)
+    self.expects(:root_segment).twice.returns(root_segment)
+    self.expects(:duration).returns(0.2)
+    data = breakdown_data
+    assert_equal 2, data.size
+    assert_equal 'Controller/foo', data[0].metric_name
+    assert_equal 'Remainder', data[1].metric_name
+  end
+
+  def test_sql_segments_default
+    root_segment = mock('root_segment') # a segment with no data
+    root_segment.expects(:[]).with(:sql).returns(false)
+    root_segment.expects(:[]).with(:sql_obfuscated).returns(false)
+    root_segment.expects(:[]).with(:key).returns(nil)
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    root_segment.stubs(:to_a).returns([root_segment])
+    other_segment = mock('other_segment') # a sql segment
+    other_segment.expects(:[]).with(:sql).returns(true)
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    other_segment.stubs(:to_a).returns([other_segment])
+    self.expects(:each_segment).multiple_yields(root_segment, other_segment)
+    assert_equal [other_segment], sql_segments
+  end
+
+  def test_time_percentage_default
+    root_segment = mock('root_segment')
+    root_segment.expects(:metric_name).returns('ROOT')
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    root_segment.stubs(:to_a).returns([root_segment])
+    other_segment = mock('other_segment')
+    other_segment.expects(:metric_name).returns('Controller/foo')
+    other_segment.expects(:duration).returns(0.1)
+    # this is for 1.9 compatibility - calling each on something calls
+    # #to_a on it - which is fun and exciting
+    other_segment.stubs(:to_a).returns([other_segment])
+    self.expects(:duration).returns(0.2)
+    self.expects(:each_segment).multiple_yields(root_segment, other_segment)
+    assert_equal 50.0, time_percentage(/Controller\/.*/)
+  end
+end

data/test/new_relic/transaction_sample/composite_segment_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/transaction_sample/composite_segment'
+class NewRelic::TransactionSample::CompositeSegmentTest < Test::Unit::TestCase
+  def test_composite_segment_creation
+    fake_segment = mock_segment
+    NewRelic::TransactionSample::CompositeSegment.new([fake_segment])
+  end
+
+  def test_detail_segments_equals
+    fake_segment = mock_segment
+    cs = NewRelic::TransactionSample::CompositeSegment.new([fake_segment])
+
+    # note that this is a bare mock
+    # nothing should be called on it, for now
+    other_fake_segment = mock('other segment')
+    cs.detail_segments = [other_fake_segment]
+
+    assert_equal cs.detail_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)
+    # note the following 'twice' - different than SummarySegment
+    segment.expects(:exit_timestamp).returns(Time.now).twice
+    segment.expects(:metric_name).returns('Custom/test/metric')
+    segment.expects(:called_segments).returns([])
+    segment
+  end
+end
+

data/test/new_relic/transaction_sample/fake_segment_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/transaction_sample/fake_segment'
+class NewRelic::TransactionSample::FakeSegmentTest < Test::Unit::TestCase
+  def test_fake_segment_creation
+    assert_nothing_raised do
+      NewRelic::TransactionSample::FakeSegment.new(0.1, 'Custom/test/metric', nil)
+    end
+  end
+
+  def test_parent_segment
+    # should be public in this class, but not in the parent class
+    s = NewRelic::TransactionSample::FakeSegment.new(0.1, 'Custom/test/metric', nil)
+    s.parent_segment = 'foo'
+    assert_equal('foo', s.instance_eval { @parent_segment } )
+  end
+end
+

data/test/new_relic/transaction_sample/segment_test.rb

@@ -0,0 +1,415 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/transaction_sample/segment'
+class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
+  def test_segment_creation
+    # basic smoke test
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal NewRelic::TransactionSample::Segment, s.class
+  end
+
+  def test_readers
+    t = Time.now
+    s = NewRelic::TransactionSample::Segment.new(t, 'Custom/test/metric', nil)
+    assert_equal(t, s.entry_timestamp)
+    assert_equal(nil, s.exit_timestamp)
+    assert_equal(nil, s.parent_segment)
+    assert_equal('Custom/test/metric', s.metric_name)
+    assert_equal(s.object_id, s.segment_id)
+  end
+
+  def test_end_trace
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    t = Time.now
+    s.end_trace(t)
+    assert_equal(t, s.exit_timestamp)
+  end
+
+  def test_add_called_segment
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal [], s.called_segments
+    fake_segment = mock('segment')
+    fake_segment.expects(:parent_segment=).with(s)
+    s.add_called_segment(fake_segment)
+    assert_equal([fake_segment], s.called_segments)
+  end
+
+  def test_to_s
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s.expects(:to_debug_str).with(0)
+    s.to_s
+  end
+
+  def test_to_array
+    parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent', 1)
+    parent.params[:test] = 'value'
+    child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child', 2)
+    child.end_trace(3)
+    parent.add_called_segment(child)
+    parent.end_trace(4)
+    expected_array = [1000, 4000, 'Custom/test/parent', {:test => 'value'},
+                      [[2000, 3000, 'Custom/test/child', {}, []]]]
+    assert_equal(expected_array, parent.to_array)
+  end
+
+  def test_to_array_with_bad_values
+    segment = NewRelic::TransactionSample::Segment.new(nil, nil, nil)
+    segment.end_trace(Rational(10, 1))
+    expected = [0, 10_000.0, "<unknown>", {}, []]
+    assert_equal(expected, segment.to_array)
+  end
+
+  if RUBY_VERSION >= '1.9.2'
+    def test_to_json
+      parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent', 1)
+      parent.params[:test] = 'value'
+      child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child', 2)
+      child.end_trace(3)
+      parent.add_called_segment(child)
+      parent.end_trace(4)
+      expected_string = "[1000,4000,\"Custom/test/parent\",{\"test\":\"value\"},[[2000,3000,\"Custom/test/child\",{},[]]]]"
+      assert_equal(expected_string, parent.to_json)
+    end
+  end
+
+  def test_path_string
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal("Custom/test/metric[]", s.path_string)
+
+    fake_segment = mock('segment')
+    fake_segment.expects(:parent_segment=).with(s)
+    fake_segment.expects(:path_string).returns('Custom/other/metric[]')
+
+
+    s.add_called_segment(fake_segment)
+    assert_equal("Custom/test/metric[Custom/other/metric[]]", s.path_string)
+  end
+
+  def test_to_s_compact
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal("Custom/test/metric", s.to_s_compact)
+
+    fake_segment = mock('segment')
+    fake_segment.expects(:parent_segment=).with(s)
+    fake_segment.expects(:to_s_compact).returns('Custom/other/metric')
+    s.add_called_segment(fake_segment)
+
+    assert_equal("Custom/test/metric{Custom/other/metric}", s.to_s_compact)
+  end
+
+  def test_to_debug_str_basic
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
+  end
+
+  def test_to_debug_str_with_params
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s.params = {:whee => 'a param'}
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n    -whee            : a param\n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
+  end
+
+  def test_to_debug_str_closed
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s.end_trace(0.1)
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n<< 100 ms Custom/test/metric\n", s.to_debug_str(0))
+  end
+
+  def test_to_debug_str_closed_with_nonnumeric
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s.end_trace("0.1")
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n<< 0.1 Custom/test/metric\n", s.to_debug_str(0))
+  end
+
+  def test_to_debug_str_one_child
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/other', nil))
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/other \n  <<  n/a Custom/test/other\n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
+    # try closing it
+    s.called_segments.first.end_trace(0.15)
+    s.end_trace(0.2)
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/other \n  << 150 ms Custom/test/other\n<< 200 ms Custom/test/metric\n", s.to_debug_str(0))
+  end
+
+  def test_to_debug_str_multichild
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/other', nil))
+    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.11, 'Custom/test/extra', nil))
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/other \n  <<  n/a Custom/test/other\n  >> 110 ms [Segment] Custom/test/extra \n  <<  n/a Custom/test/extra\n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
+    ending = 0.12
+    s.called_segments.each { |x| x.end_trace(ending += 0.01) }
+    s.end_trace(0.2)
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/other \n  << 130 ms Custom/test/other\n  >> 110 ms [Segment] Custom/test/extra \n  << 140 ms Custom/test/extra\n<< 200 ms Custom/test/metric\n", s.to_debug_str(0))
+  end
+
+  def test_to_debug_str_nested
+    inner = NewRelic::TransactionSample::Segment.new(0.2, 'Custom/test/inner', nil)
+    middle = NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/middle', nil)
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    middle.add_called_segment(inner)
+    s.add_called_segment(middle)
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/middle \n    >> 200 ms [Segment] Custom/test/inner \n    <<  n/a Custom/test/inner\n  <<  n/a Custom/test/middle\n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
+
+    # close them
+    inner.end_trace(0.21)
+    middle.end_trace(0.22)
+    s.end_trace(0.23)
+    assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/middle \n    >> 200 ms [Segment] Custom/test/inner \n    << 210 ms Custom/test/inner\n  << 220 ms Custom/test/middle\n<< 230 ms Custom/test/metric\n", s.to_debug_str(0))
+  end
+
+  def test_called_segments_default
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal([], s.called_segments)
+  end
+
+  def test_called_segments_with_segments
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    fake_segment = mock('segment')
+    fake_segment.expects(:parent_segment=).with(s)
+    s.add_called_segment(fake_segment)
+
+    assert_equal([fake_segment], s.called_segments)
+  end
+
+  def test_duration
+    fake_entry_timestamp = mock('entry timestamp')
+    fake_exit_timestamp = mock('exit timestamp')
+    fake_result = mock('numeric')
+    fake_exit_timestamp.expects(:-).with(fake_entry_timestamp).returns(fake_result)
+    fake_result.expects(:to_f).returns(0.5)
+
+    s = NewRelic::TransactionSample::Segment.new(fake_entry_timestamp, 'Custom/test/metric', nil)
+    s.end_trace(fake_exit_timestamp)
+    assert_equal(0.5, s.duration)
+  end
+
+  def test_exclusive_duration_no_children
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s.expects(:duration).returns(0.5)
+    assert_equal(0.5, s.exclusive_duration)
+  end
+
+  def test_exclusive_duration_with_children
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    s.expects(:duration).returns(0.5)
+
+    fake_segment = mock('segment')
+    fake_segment.expects(:parent_segment=).with(s)
+    fake_segment.expects(:duration).returns(0.1)
+
+    s.add_called_segment(fake_segment)
+
+    assert_equal(0.4, s.exclusive_duration)
+  end
+
+  def test_count_segments_default
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal(1, s.count_segments)
+  end
+
+  def test_count_segments_with_children
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    fake_segment = mock('segment')
+    fake_segment.expects(:parent_segment=).with(s)
+    fake_segment.expects(:count_segments).returns(1)
+
+    s.add_called_segment(fake_segment)
+
+    assert_equal(2, s.count_segments)
+    end
+
+  def test_truncate_returns_number_of_elements
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal(1, s.truncate(1))
+    dup = s.dup
+    s.called_segments = [dup]
+    assert_equal(2, s.truncate(2))
+
+    s.called_segments = [dup, dup]
+    assert_equal(3, s.truncate(3))
+  end
+
+
+  def test_truncate_default
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    assert_equal(1, s.truncate(1))
+  end
+
+  def test_truncate_with_a_child
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    fake_segment = mock('segment')
+    fake_segment.expects(:parent_segment=).with(s)
+    fake_segment.expects(:truncate).with(1).returns(1)
+
+    s.add_called_segment(fake_segment)
+
+    assert_equal(2, s.truncate(2))
+    assert_equal([fake_segment], s.called_segments)
+
+    assert_equal(1, s.truncate(1))
+    assert_equal([], s.called_segments)
+  end
+
+  def test_truncate_with_multiple_children
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    fake_segment = mock('segment')
+    fake_segment.expects(:truncate).with(2).returns(1)
+
+    other_segment = mock('other segment')
+    other_segment.expects(:truncate).with(1).returns(1)
+
+    s.called_segments = [fake_segment, other_segment]
+    assert_equal(3, s.truncate(3))
+    assert_equal([fake_segment, other_segment], s.called_segments)
+  end
+
+  def test_truncate_removes_elements
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    fake_segment = mock('segment')
+    fake_segment.expects(:truncate).with(1).returns(1)
+
+    other_segment = mock('other segment')
+
+    s.called_segments = [fake_segment, other_segment]
+    assert_equal(2, s.truncate(2))
+    assert_equal([fake_segment], s.called_segments)
+  end
+
+  def test_key_equals
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    # doing this to hold the reference to the hash
+    params = {}
+    s.params = params
+    assert_equal(params, s.params)
+
+    # should delegate to the same hash we have above
+    s[:foo] = 'correct'
+
+    assert_equal('correct', params[:foo])
+  end
+
+  def test_key
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s.params = {:foo => 'correct'}
+    assert_equal('correct', s[:foo])
+  end
+
+  def test_params
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    # should have a default value
+    assert_equal(nil, s.instance_eval { @params })
+    assert_equal({}, s.params)
+
+    # should otherwise take the value from the @params var
+    s.instance_eval { @params = {:foo => 'correct'} }
+    assert_equal({:foo => 'correct'}, s.params)
+  end
+
+  def test_each_segment_default
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    # in the base case it just yields the block to itself
+    count = 0
+    s.each_segment do |x|
+      count += 1
+      assert_equal(s, x)
+    end
+    # should only run once
+    assert_equal(1, count)
+  end
+
+  def test_each_segment_with_children
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    fake_segment = mock('segment')
+    fake_segment.expects(:parent_segment=).with(s)
+    fake_segment.expects(:each_segment).yields(fake_segment)
+
+    s.add_called_segment(fake_segment)
+
+    count = 0
+    s.each_segment do |x|
+      count += 1
+    end
+
+    assert_equal(2, count)
+  end
+
+  def test_each_segment_with_nest_tracking
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    summary = mock('summary')
+    summary.expects(:current_nest_count).twice.returns(0).then.returns(1)
+    summary.expects(:current_nest_count=).twice
+    s.each_segment_with_nest_tracking do |x|
+      summary
+    end
+  end
+
+  def test_find_segment_default
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    id_to_find = s.segment_id
+    # should return itself in the base case
+    assert_equal(s, s.find_segment(id_to_find))
+  end
+
+  def test_find_segment_not_found
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal(nil, s.find_segment(-1))
+  end
+
+  def test_find_segment_with_children
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    id_to_find = s.segment_id
+    # should return itself in the base case
+    assert_equal(s, s.find_segment(id_to_find))
+  end
+
+  def test_explain_sql_raising_an_error
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    config = mock('config')
+    s.params = {:sql => 'SELECT', :connection_config => config}
+    connection = mock('connection')
+    NewRelic::Agent::Database.expects(:get_connection).with(config).raises(RuntimeError.new("whee"))
+    assert_nothing_raised do
+      s.explain_sql
+    end
+  end
+
+  def test_params_equal
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal(nil, s.instance_eval { @params })
+
+    params = {:foo => 'correct'}
+
+    s.params = params
+    assert_equal(params, s.instance_eval { @params })
+  end
+  
+  def test_obfuscated_sql
+    sql = 'select * from table where id = 1'
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s[:sql] = sql
+    assert_equal('select * from table where id = ?', s.obfuscated_sql)
+  end
+
+  def test_called_segments_equals
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal(nil, s.instance_eval { @called_segments })
+    s.called_segments = [1, 2, 3]
+    assert_equal([1, 2, 3], s.instance_eval { @called_segments })
+  end
+
+  def test_parent_segment_equals
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    assert_equal(nil, s.instance_eval { @parent_segment })
+    fake_segment = mock('segment')
+    s.send(:parent_segment=, fake_segment)
+    assert_equal(fake_segment, s.parent_segment)
+  end
+end
+