RubyGems - newrelic_rpm - Versions diffs - 4.1.0.333 → 4.2.0.334 - Mend

newrelic_rpm 4.1.0.333 → 4.2.0.334

Files changed (788) hide show

data/test/new_relic/agent/transaction/abstract_segment_test.rb DELETED Viewed

@@ -1,103 +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/agent/transaction'
-require 'new_relic/agent/transaction/abstract_segment'
-module NewRelic
-  module Agent
-    class Transaction
-      class AbstractSegmentTest < Minitest::Test
-        class BasicSegment < AbstractSegment
-          def record_metrics
-            metric_cache.record_scoped_and_unscoped name, duration, exclusive_duration
-            metric_cache.record_unscoped "Basic/all", duration, exclusive_duration
-          end
-        end
-        def setup
-          freeze_time
-        end
-        def teardown
-          NewRelic::Agent.drop_buffered_data
-        end
-        def test_segment_is_nameable
-          segment = BasicSegment.new  "Custom/basic/segment"
-          assert_equal "Custom/basic/segment", segment.name
-        end
-        def test_segment_tracks_timing_information
-          segment = BasicSegment.new "Custom/basic/segment"
-          segment.start
-          assert_equal Time.now, segment.start_time
-          advance_time 1.0
-          segment.finish
-          assert_equal Time.now, segment.end_time
-          assert_equal 1.0, segment.duration
-          assert_equal 1.0, segment.exclusive_duration
-        end
-        def test_segment_records_metrics
-          in_transaction do |txn|
-            segment = BasicSegment.new "Custom/basic/segment"
-            txn.add_segment segment
-            segment.start
-            advance_time 1.0
-            segment.finish
-          end
-          assert_metrics_recorded ["Custom/basic/segment", "Basic/all"]
-        end
-        def test_segment_records_metrics_in_local_cache_if_part_of_transaction
-          segment = BasicSegment.new "Custom/basic/segment"
-          in_transaction "test_transaction" do |txn|
-            txn.add_segment segment
-            segment.start
-            advance_time 1.0
-            segment.finish
-            refute_metrics_recorded ["Custom/basic/segment", "Basic/all"]
-          end
-          #local metrics will be merged into global store at the end of the transction
-          assert_metrics_recorded ["Custom/basic/segment", "Basic/all"]
-        end
-        # this preserves a strange case that is currently present in the agent where for some
-        # segments we would like to create a TT node for the segment, but not record
-        # metrics
-        def test_segments_will_not_record_metrics_when_turned_off
-          in_transaction do |txn|
-            segment = BasicSegment.new "Custom/basic/segment"
-            txn.add_segment segment
-            segment.record_metrics = false
-            segment.start
-            advance_time 1.0
-            segment.finish
-          end
-          refute_metrics_recorded ["Custom/basic/segment", "Basic/all"]
-        end
-        def test_segment_complete_callback_executes_when_segment_finished
-          in_transaction do |txn|
-            segment = BasicSegment.new "Custom/basic/segment"
-            txn.add_segment segment
-            segment.expects(:segment_complete)
-            segment.start
-            advance_time 1.0
-            segment.finish
-          end
-        end
-      end
-    end
-  end
-end

data/test/new_relic/agent/transaction/attributes_test.rb DELETED Viewed

@@ -1,268 +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/agent/transaction/attributes'
-require 'new_relic/agent/attribute_filter'
-class AttributesTest < Minitest::Test
-  Attributes      = NewRelic::Agent::Transaction::Attributes
-  AttributeFilter = NewRelic::Agent::AttributeFilter
-  def setup
-    # Lots of tests that just want the default behavior, so make sure filter
-    # is updated to that base
-    NewRelic::Agent.instance.refresh_attribute_filter
-  end
-  def test_adds_custom_attribute
-    attributes = create_attributes
-    attributes.merge_custom_attributes(:foo => "bar")
-    assert_equal({"foo" => "bar"}, attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER))
-  end
-  def test_disable_custom_attributes
-    with_config({:'transaction_tracer.attributes.enabled' => false}) do
-      attributes = create_attributes
-      attributes.merge_custom_attributes(:foo => "bar")
-      assert_empty attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-    end
-  end
-  def test_disable_custom_attributes_in_high_security_mode
-    with_config(:high_security => true) do
-      attributes = create_attributes
-      attributes.merge_custom_attributes(:foo => "bar")
-      assert_empty attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-    end
-  end
-  def test_disable_merging_custom_attributes_in_high_security_mode
-    with_config(:high_security => true) do
-      attributes = create_attributes
-      attributes.merge_custom_attributes(:foo => "bar")
-      assert_empty attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-    end
-  end
-  def test_merge_custom_attributes
-      attributes = create_attributes
-      params = {:foo => {:bar => "baz"}}
-      attributes.merge_custom_attributes(params)
-      assert_equal({"foo.bar" => "baz"}, attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER))
-  end
-  def test_adds_agent_attribute
-    attributes = create_attributes
-    attributes.add_agent_attribute(:foo, "bar", AttributeFilter::DST_ALL)
-    assert_equal({:foo => "bar"}, attributes.agent_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER))
-  end
-  def test_disable_agent_attributes
-    with_config({:'transaction_tracer.attributes.enabled' => false}) do
-      attributes = create_attributes
-      attributes.add_agent_attribute(:foo, "bar", AttributeFilter::DST_ALL)
-      assert_empty attributes.agent_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-    end
-  end
-  def test_agent_attributes_obey_default_destinations
-    attributes = create_attributes
-    attributes.add_agent_attribute(:foo, "bar", AttributeFilter::DST_ERROR_COLLECTOR)
-    assert_empty attributes.agent_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-  end
-  def test_adds_intrinsic_attribute_to_only_traces_and_errors
-    attributes = create_attributes
-    attributes.add_intrinsic_attribute(:foo, "bar")
-    expected = {:foo => "bar"}
-    assert_equal(expected, attributes.intrinsic_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER))
-    assert_equal(expected, attributes.intrinsic_attributes_for(AttributeFilter::DST_ERROR_COLLECTOR))
-    assert_empty(attributes.intrinsic_attributes_for(AttributeFilter::DST_TRANSACTION_EVENTS))
-    assert_empty(attributes.intrinsic_attributes_for(AttributeFilter::DST_BROWSER_MONITORING))
-  end
-  def test_intrinsic_attributes_arent_disabled_for_traces_and_errors
-    with_config({:'transaction_tracer.attributes.enabled' => false}) do
-      attributes = create_attributes
-      attributes.add_intrinsic_attribute(:foo, "bar")
-      expected = {:foo => "bar"}
-      assert_equal(expected, attributes.intrinsic_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER))
-      assert_equal(expected, attributes.intrinsic_attributes_for(AttributeFilter::DST_ERROR_COLLECTOR))
-      assert_empty(attributes.intrinsic_attributes_for(AttributeFilter::DST_TRANSACTION_EVENTS))
-      assert_empty(attributes.intrinsic_attributes_for(AttributeFilter::DST_BROWSER_MONITORING))
-    end
-  end
-  MULTIBYTE_CHARACTER = "七"
-  def test_truncates_multibyte_string
-    # Leading single byte character makes byteslice yield invalid string
-    value = "j" + MULTIBYTE_CHARACTER * 1000
-    attributes = create_attributes
-    attributes.merge_custom_attributes(:key => value)
-    custom_attributes = attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-    result = custom_attributes["key"]
-    assert result.valid_encoding?
-    assert result.bytesize < NewRelic::Agent::Transaction::Attributes::VALUE_LIMIT
-  end
-  def test_truncates_multibyte_symbol
-    # Leading single byte character makes byteslice yield invalid string
-    value = ("j" + MULTIBYTE_CHARACTER * 1000).to_sym
-    attributes = create_attributes
-    attributes.merge_custom_attributes(:key => value)
-    custom_attributes = attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-    result = custom_attributes["key"]
-    assert result.valid_encoding?
-    assert result.bytesize < NewRelic::Agent::Transaction::Attributes::VALUE_LIMIT
-  end
-  def test_limits_key_length
-    key = "x" * (Attributes::KEY_LIMIT + 1)
-    expects_logging(:warn, includes(key))
-    attributes = create_attributes
-    attributes.merge_custom_attributes(key => "")
-    assert_custom_attributes_empty(attributes)
-  end
-  def test_limits_key_length_by_bytes
-    key = MULTIBYTE_CHARACTER * Attributes::KEY_LIMIT
-    expects_logging(:warn, includes(key))
-    attributes = create_attributes
-    attributes.merge_custom_attributes(key => "")
-    assert_custom_attributes_empty(attributes)
-  end
-  def test_limits_key_length_symbol
-    key = ("x" * (Attributes::KEY_LIMIT + 1)).to_sym
-    expects_logging(:warn, includes(key.to_s))
-    attributes = create_attributes
-    attributes.merge_custom_attributes(key => "")
-    assert_custom_attributes_empty(attributes)
-  end
-  def test_limits_key_length_on_merge_custom_attributes
-    key = ("x" * (Attributes::KEY_LIMIT + 1)).to_sym
-    expects_logging(:warn, includes(key.to_s))
-    attributes = create_attributes
-    attributes.merge_custom_attributes(key => "")
-    assert_custom_attributes_empty(attributes)
-  end
-  def test_allows_non_string_key_type
-    attributes = create_attributes
-    attributes.merge_custom_attributes(1 => "value")
-    assert_equal "value", custom_attributes(attributes)["1"]
-  end
-  def test_truncates_string_values
-    value = "x" * 1000
-    attributes = create_attributes
-    attributes.merge_custom_attributes(:key => value)
-    assert_equal Attributes::VALUE_LIMIT, custom_attributes(attributes)["key"].length
-  end
-  def test_truncates_symbol_values
-    value = ("x" * 1000).to_sym
-    attributes = create_attributes
-    attributes.merge_custom_attributes(:key => value)
-    assert_equal Attributes::VALUE_LIMIT, custom_attributes(attributes)["key"].length
-  end
-  def test_leaves_numbers_alone
-    attributes = create_attributes
-    attributes.merge_custom_attributes(:key => 42)
-    assert_equal 42, custom_attributes(attributes)["key"]
-  end
-  def test_limits_attribute_count
-    ::NewRelic::Agent.logger.expects(:warn).once
-    attributes = create_attributes
-    100.times do |i|
-      attributes.merge_custom_attributes(i.to_s => i)
-    end
-    assert_equal Attributes::COUNT_LIMIT, custom_attributes(attributes).length
-  end
-  def test_merge_untrusted_agent_attributes
-    with_config(:'attributes.include' => "request.parameters.*") do
-      attributes = create_attributes
-      params = {:foo => {:bar => "baz"}}
-      attributes.merge_untrusted_agent_attributes(params, 'request.parameters', AttributeFilter::DST_NONE)
-      assert_equal({"request.parameters.foo.bar" => "baz"}, agent_attributes(attributes))
-    end
-  end
-  def test_merge_untrusted_agent_attributes_drops_long_keys
-    with_config(:'attributes.include' => "request.parameters.*") do
-      attributes = create_attributes
-      params = {
-        "a"*256 => "too long",
-        "foo" => "bar"
-      }
-      attributes.merge_untrusted_agent_attributes(params, 'request.parameters', AttributeFilter::DST_NONE)
-      assert_equal({"request.parameters.foo" => "bar"}, agent_attributes(attributes))
-    end
-  end
-  def test_merge_untrusted_agent_attributes_disallowed_in_high_security
-    with_config(:high_security => true, :'attributes.include' => "request.parameters.*") do
-      attributes = create_attributes
-      params = { "sneaky" => "code" }
-      attributes.merge_untrusted_agent_attributes('request.parameters', params, AttributeFilter::DST_NONE)
-      assert_empty agent_attributes(attributes)
-    end
-  end
-  def create_attributes
-    filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
-    NewRelic::Agent::Transaction::Attributes.new(filter)
-  end
-  def custom_attributes(attributes)
-    attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-  end
-  def assert_custom_attributes_empty(attributes)
-    assert_empty custom_attributes(attributes)
-  end
-  def agent_attributes(attributes)
-    attributes.agent_attributes_for(AttributeFilter::DST_TRANSACTION_TRACER)
-  end
-end

data/test/new_relic/agent/transaction/datastore_segment_test.rb DELETED Viewed

@@ -1,336 +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/agent/transaction/datastore_segment'
-module NewRelic
-  module Agent
-    class Transaction
-      class DatastoreSegmentTest < Minitest::Test
-        def setup
-          freeze_time
-        end
-        def teardown
-          NewRelic::Agent.drop_buffered_data
-        end
-        def test_datastore_segment_name_with_collection
-          segment = DatastoreSegment.new "SQLite", "insert", "Blog"
-          assert_equal "Datastore/statement/SQLite/Blog/insert", segment.name
-        end
-        def test_datastore_segment_name_with_operation
-          segment = DatastoreSegment.new "SQLite", "select"
-          assert_equal "Datastore/operation/SQLite/select", segment.name
-        end
-        def test_segment_does_not_record_metrics_outside_of_txn
-          segment = DatastoreSegment.new "SQLite", "insert", "Blog"
-          segment.start
-          advance_time 1
-          segment.finish
-          refute_metrics_recorded [
-            "Datastore/statement/SQLite/Blog/insert",
-            "Datastore/operation/SQLite/insert",
-            "Datastore/SQLite/allWeb",
-            "Datastore/SQLite/all",
-            "Datastore/allWeb",
-            "Datastore/all"
-          ]
-        end
-        def test_segment_records_expected_metrics
-          in_web_transaction "text_txn" do
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "insert", "Blog"
-            segment.start
-            advance_time 1
-            segment.finish
-          end
-          assert_metrics_recorded [
-            "Datastore/statement/SQLite/Blog/insert",
-            "Datastore/operation/SQLite/insert",
-            "Datastore/SQLite/allWeb",
-            "Datastore/SQLite/all",
-            "Datastore/allWeb",
-            "Datastore/all"
-          ]
-        end
-        def test_segment_records_expected_metrics_without_collection
-          in_web_transaction "text_txn" do
-            segment = Transaction.start_datastore_segment "SQLite", "select"
-            segment.start
-            advance_time 1
-            segment.finish
-          end
-          assert_metrics_recorded [
-            "Datastore/operation/SQLite/select",
-            "Datastore/SQLite/allWeb",
-            "Datastore/SQLite/all",
-            "Datastore/allWeb",
-            "Datastore/all"
-          ]
-        end
-        def test_segment_records_expected_metrics_with_instance_identifier
-          in_web_transaction "text_txn" do
-            segment = Transaction.start_datastore_segment "SQLite", "select", nil, "jonan-01", "1337807"
-            segment.start
-            advance_time 1
-            segment.finish
-          end
-          assert_metrics_recorded [
-            "Datastore/instance/SQLite/jonan-01/1337807",
-            "Datastore/operation/SQLite/select",
-            "Datastore/SQLite/allWeb",
-            "Datastore/SQLite/all",
-            "Datastore/allWeb",
-            "Datastore/all"
-          ]
-        end
-        def test_segment_records_expected_metrics_with_instance_identifier_host_only
-          in_web_transaction "text_txn" do
-            segment = Transaction.start_datastore_segment "SQLite", "select", nil, "jonan-01"
-            segment.start
-            advance_time 1
-            segment.finish
-          end
-          assert_metrics_recorded [
-            "Datastore/instance/SQLite/jonan-01/unknown",
-            "Datastore/operation/SQLite/select",
-            "Datastore/SQLite/allWeb",
-            "Datastore/SQLite/all",
-            "Datastore/allWeb",
-            "Datastore/all"
-          ]
-        end
-        def test_segment_records_expected_metrics_with_instance_identifier_port_only
-          in_web_transaction "text_txn" do
-            segment = Transaction.start_datastore_segment "SQLite", "select", nil, nil, 1337807
-            segment.start
-            advance_time 1
-            segment.finish
-          end
-          assert_metrics_recorded [
-            "Datastore/instance/SQLite/unknown/1337807",
-            "Datastore/operation/SQLite/select",
-            "Datastore/SQLite/allWeb",
-            "Datastore/SQLite/all",
-            "Datastore/allWeb",
-            "Datastore/all"
-          ]
-        end
-        def test_segment_does_not_record_expected_metrics_with_empty_data
-          in_web_transaction "text_txn" do
-            segment = Transaction.start_datastore_segment "SQLite", "select", nil
-            segment.start
-            advance_time 1
-            segment.finish
-          end
-          assert_metrics_not_recorded "Datastore/instance/SQLite/unknown/unknown"
-        end
-        def test_segment_does_not_record_instance_id_metrics_when_disabled
-          with_config(:'datastore_tracer.instance_reporting.enabled' => false) do
-            in_web_transaction "text_txn" do
-              segment = Transaction.start_datastore_segment "SQLite", "select", nil, "jonan-01", "1337807"
-              segment.start
-              advance_time 1
-              segment.finish
-            end
-            assert_metrics_not_recorded "Datastore/instance/SQLite/jonan-01/1337807"
-          end
-        end
-        def test_add_instance_identifier_segment_parameter
-          segment = nil
-          in_transaction do
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, "jonan-01", "1337807"
-            advance_time 1
-            segment.finish
-          end
-          sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-          node = find_node_with_name(sample, segment.name)
-          assert_equal "jonan-01", node.params[:host]
-          assert_equal "1337807", node.params[:port_path_or_id]
-        end
-        def test_localhost_replaced_by_system_hostname
-          NewRelic::Agent::Hostname.stubs(:get).returns("jonan.gummy_planet")
-          %w[localhost 0.0.0.0 127.0.0.1 0:0:0:0:0:0:0:1 0:0:0:0:0:0:0:0 ::1 ::].each do |host|
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", "blogs", host, "1337"
-            segment.finish
-            assert_equal "jonan.gummy_planet", segment.host
-          end
-        end
-        def test_does_not_add_instance_identifier_segment_parameter_when_disabled
-          with_config(:'datastore_tracer.instance_reporting.enabled' => false) do
-            segment = nil
-            in_transaction do
-              segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, "localhost", "1337807"
-              advance_time 1
-              segment.finish
-            end
-            sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-            node = find_node_with_name(sample, segment.name)
-            refute node.params.key? :host
-            refute node.params.key? :port_path_or_id
-          end
-        end
-        def test_add_database_name_segment_parameter
-          segment = nil
-          in_transaction do
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, nil, nil, "pizza_cube"
-            advance_time 1
-            segment.finish
-          end
-          sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-          node = find_node_with_name(sample, segment.name)
-          assert_equal node.params[:database_name], "pizza_cube"
-        end
-        def test_does_not_add_database_name_segment_parameter_when_disabled
-          with_config(:'datastore_tracer.database_name_reporting.enabled' => false) do
-            segment = nil
-            in_transaction do
-              segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, nil, nil, "pizza_cube"
-              advance_time 1
-              segment.finish
-            end
-            sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-            node = find_node_with_name(sample, segment.name)
-            refute node.params.key? :database_name
-          end
-        end
-        def test_notice_sql
-          in_transaction do
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select"
-            segment.notice_sql "select * from blogs"
-            advance_time 2.0
-            Agent.instance.transaction_sampler.expects(:notice_sql_statement).with(segment.sql_statement, 2.0)
-            Agent.instance.sql_sampler.expects(:notice_sql_statement) do |statement, name, duration|
-              assert_equal segment.sql_statement.sql, statement.sql_statement
-              assert_equal segment.name, name
-              assert_equal duration, 2.0
-            end
-            segment.finish
-          end
-        end
-        def test_notice_sql_creates_database_statement_with_identifier
-          in_transaction do
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, "jonan.gummy_planet", "1337"
-            segment.notice_sql "select * from blogs"
-            segment.finish
-            assert_equal "jonan.gummy_planet", segment.sql_statement.host
-            assert_equal "1337", segment.sql_statement.port_path_or_id
-          end
-        end
-        def test_notice_sql_creates_database_statement_with_database_name
-          in_transaction do
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, nil, nil, "pizza_cube"
-            segment.notice_sql "select * from blogs"
-            segment.finish
-            assert_equal "pizza_cube", segment.sql_statement.database_name
-          end
-        end
-        def test_internal_notice_sql
-          explainer = stub(:explainer)
-          in_transaction do
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select"
-            segment._notice_sql "select * from blogs", {:adapter => :sqlite}, explainer
-            advance_time 2.0
-            Agent.instance.transaction_sampler.expects(:notice_sql_statement).with(segment.sql_statement, 2.0)
-            Agent.instance.sql_sampler.expects(:notice_sql_statement) do |statement, name, duration|
-              assert_equal segment.sql_statement.sql, statement.sql_statement
-              assert_equal segment.name, name
-              assert_equal duration, 2.0
-            end
-            segment.finish
-          end
-        end
-        def test_notice_nosql_statement
-          statement = "set mykey 123"
-          in_transaction do
-            segment = NewRelic::Agent::Transaction.start_datastore_segment "Redis", "set"
-            segment.notice_nosql_statement statement
-            advance_time 2.0
-            Agent.instance.transaction_sampler.expects(:notice_nosql_statement).with(statement, 2.0)
-            segment.finish
-          end
-        end
-        def test_set_instance_info_with_valid_data
-          segment = DatastoreSegment.new "SQLite", "select", nil
-          segment.set_instance_info 'jonan.gummy_planet', 1337807
-          assert_equal 'jonan.gummy_planet', segment.host
-          assert_equal '1337807', segment.port_path_or_id
-        end
-        def test_set_instance_info_with_empty_host
-          segment = DatastoreSegment.new "SQLite", "select", nil
-          segment.set_instance_info nil, 1337807
-          assert_equal 'unknown', segment.host
-          assert_equal '1337807', segment.port_path_or_id
-        end
-        def test_set_instance_info_with_empty_port_path_or_id
-          segment = DatastoreSegment.new "SQLite", "select", nil
-          segment.set_instance_info 'jonan.gummy_planet', nil
-          assert_equal 'jonan.gummy_planet', segment.host
-          assert_equal 'unknown', segment.port_path_or_id
-        end
-        def test_set_instance_info_with_empty_data
-          segment = DatastoreSegment.new "SQLite", "select", nil
-          segment.set_instance_info nil, nil
-          assert_nil segment.host
-          assert_nil segment.port_path_or_id
-          segment.set_instance_info '', ''
-          assert_nil segment.host
-          assert_nil segment.port_path_or_id
-        end
-      end
-    end
-  end
-end