newrelic_rpm 3.11.2.286 → 3.12.0.288

data/test/new_relic/agent/transaction/force_persist_sample_buffer_test.rb

@@ -1,52 +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'))
-
-class NewRelic::Agent::Transaction
-  class ForcePersistSampleBufferTest < Minitest::Test
-    def setup
-      @buffer = ForcePersistSampleBuffer.new
-    end
-
-    def test_stores_forced_sample
-      sample = stub(:force_persist => true)
-      @buffer.store(sample)
-
-      assert_equal([sample], @buffer.samples)
-    end
-
-    def test_does_not_store_forced_sample
-      sample = stub(:force_persist => false)
-      @buffer.store(sample)
-
-      assert(@buffer.samples.empty?)
-    end
-
-    def test_harvest_samples
-      sample = stub(:force_persist => true)
-      @buffer.store(sample)
-
-      result = @buffer.harvest_samples
-
-      assert_equal([sample], result)
-    end
-
-    def test_harvest_samples_resets
-      sample = stub(:force_persist => true)
-      @buffer.store(sample)
-
-      @buffer.harvest_samples
-
-      assert(@buffer.samples.empty?)
-    end
-
-    def test_intermediate_storage_keeps_N_longest_samples
-      samples = (1..100).map { |i| stub(i.to_s, :force_persist => true, :duration => i) }
-      samples.each {|s| @buffer.store(s)}
-
-      assert_equal(samples.last(@buffer.capacity), @buffer.samples)
-    end
-  end
-end

data/test/new_relic/transaction_analysis_test.rb

@@ -1,125 +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/transaction_analysis'
-class NewRelic::TransactionAnalysisTest < Minitest::Test
-  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

@@ -1,38 +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/transaction_sample/composite_segment'
-class NewRelic::TransactionSample::CompositeSegmentTest < Minitest::Test
-  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

@@ -1,18 +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/transaction_sample/fake_segment'
-class NewRelic::TransactionSample::FakeSegmentTest < Minitest::Test
-  def test_fake_segment_creation
-    NewRelic::TransactionSample::FakeSegment.new(0.1, 'Custom/test/metric')
-  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')
-    s.parent_segment = 'foo'
-    assert_equal('foo', s.instance_eval { @parent_segment } )
-  end
-end

data/test/new_relic/transaction_sample/segment_test.rb

@@ -1,361 +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/transaction_sample/segment'
-class NewRelic::TransactionSample::SegmentTest < Minitest::Test
-  def test_segment_creation
-    # basic smoke test
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-    assert_equal NewRelic::TransactionSample::Segment, s.class
-  end
-
-  def test_readers
-    t = Time.now
-    s = NewRelic::TransactionSample::Segment.new(t, 'Custom/test/metric')
-    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')
-    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')
-    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')
-    s.expects(:to_debug_str).with(0)
-    s.to_s
-  end
-
-  def test_to_array
-    parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent')
-    parent.params[:test] = 'value'
-    child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child')
-    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)
-    segment.end_trace(Rational(10, 1))
-    expected = [0, 10_000.0, "<unknown>", {}, []]
-    assert_equal(expected, segment.to_array)
-  end
-
-  def test_path_string
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-    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')
-    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')
-    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')
-    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')
-    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')
-    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')
-    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/other'))
-    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')
-    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/other'))
-    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.11, 'Custom/test/extra'))
-    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')
-    middle = NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/middle')
-    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric')
-    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')
-    assert_equal([], s.called_segments)
-  end
-
-  def test_called_segments_with_segments
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-    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')
-    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')
-    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')
-
-    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')
-    assert_equal(1, s.count_segments)
-  end
-
-  def test_count_segments_with_children
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-
-    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_key_equals
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-    # 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')
-    s.params = {:foo => 'correct'}
-    assert_equal('correct', s[:foo])
-  end
-
-  def test_params
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-
-    # 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')
-    # 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')
-
-    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')
-
-    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')
-    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')
-    assert_equal(nil, s.find_segment(-1))
-  end
-
-  def test_find_segment_with_children
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-    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')
-    config = { :adapter => 'mysql' }
-    statement = NewRelic::Agent::Database::Statement.new('SELECT')
-    statement.config = config
-    statement.explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
-    s.params = {:sql => statement}
-    NewRelic::Agent::Database.expects(:get_connection).with(config).raises(RuntimeError.new("whee"))
-    s.explain_sql
-  end
-
-  def test_explain_sql_can_handle_missing_config
-    # If TT segment came over from Resque child, might not be a Statement
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-    s.params = { :sql => "SELECT * FROM galaxy" }
-    s.explain_sql
-  end
-
-  def test_explain_sql_can_use_already_existing_plan
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-    s.params = {
-      :sql => "SELECT * FROM galaxy",
-      :explain_plan => "EXPLAIN IT!"
-    }
-
-    assert_equal("EXPLAIN IT!", s.explain_sql)
-  end
-
-  def test_params_equal
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
-    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')
-    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')
-    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')
-    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