dolores_rpm 3.2.0.2

data/test/new_relic/transaction_sample/segment_test.rb

@@ -0,0 +1,389 @@
+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_json
+    t = Time.now
+    s = NewRelic::TransactionSample::Segment.new(t, 'Custom/test/metric', nil)
+    assert_equal({ :entry_timestamp => t, :exit_timestamp => nil, :metric_name => 'Custom/test/metric', :segment_id => s.object_id }.to_json, s.to_json)
+  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
+

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,164 @@
+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::Agent::Database.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[:explain_plan]
+      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[:explain_plan] || 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[:explain_plan] || 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)
+    
+    s.each_segment do |segment|
+      if segment.params[:explain_plan]
+        explanation = segment.params[:explain_plan]
+
+        assert_kind_of Array, explanation
+        assert_equal([nil, [["QUERY RESULT"]]], explanation)
+      end
+    end
+  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[:explain_plan]
+      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