RubyGems - newrelic_rpm - Versions diffs - 3.12.0.288 → 9.10.2 - Mend

newrelic_rpm 3.12.0.288 → 9.10.2

Files changed (1319) hide show

data/test/new_relic/agent/inbound_request_monitor_test.rb DELETED Viewed

@@ -1,49 +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/inbound_request_monitor'
-module NewRelic::Agent
-  class InboundRequestMonitorTest < Minitest::Test
-    ENCODING_KEY_NOOP         = "\0"
-    def setup
-      @events  = NewRelic::Agent::EventListener.new
-      @monitor = NewRelic::Agent::InboundRequestMonitor.new(@events)
-      @config = { :encoding_key => ENCODING_KEY_NOOP }
-      NewRelic::Agent.config.add_config_for_testing(@config)
-      class << @monitor
-        define_method(:on_finished_configuring) do |*_|
-        end
-      end
-      @events.notify(:finished_configuring)
-    end
-    def teardown
-      NewRelic::Agent.config.remove_config(@config)
-    end
-    def test_deserialize
-      payload = @monitor.obfuscator.obfuscate("[1,2,3]")
-      assert_equal [1, 2, 3], @monitor.deserialize_header(payload, "the_key")
-    end
-    def test_deserialize_nonsense
-      expects_logging(:debug, includes("the_key"))
-      assert_nil @monitor.deserialize_header("asdf", "the_key")
-    end
-    def test_deserialize_with_invalid_json
-      payload = @monitor.obfuscator.obfuscate("[1,2,3")
-      expects_logging(:debug, includes("the_key"))
-      assert_nil @monitor.deserialize_header(payload, "the_key")
-    end
-  end
-end

data/test/new_relic/agent/instrumentation/action_controller_subscriber_test.rb DELETED Viewed

@@ -1,299 +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.
-if defined?(::Rails)
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-require 'new_relic/agent/instrumentation/action_controller_subscriber'
-class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minitest::Test
-  class TestController
-    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-    def self.controller_path
-      'test'
-    end
-    def action_name
-      'test'
-    end
-    newrelic_ignore :only => :ignored_action
-    newrelic_ignore_apdex :only => :ignored_apdex
-    newrelic_ignore_enduser :only => :ignored_enduser
-  end
-  def setup
-    freeze_time
-    @subscriber = NewRelic::Agent::Instrumentation::ActionControllerSubscriber.new
-    NewRelic::Agent.drop_buffered_data
-    @entry_payload = {
-      :controller => TestController.to_s,
-      :action => 'index',
-      :format => :html,
-      :method => 'GET',
-      :path => '/tests',
-      :params => { :controller => 'test_controller', :action => 'index' },
-    }
-    @exit_payload = @entry_payload.merge(:status => 200, :view_runtime => 5.0,
-                                         :db_runtime => 0.5 )
-    @stats_engine = NewRelic::Agent.instance.stats_engine
-    @stats_engine.clear_stats
-    NewRelic::Agent.manual_start
-    NewRelic::Agent::TransactionState.tl_clear_for_testing
-  end
-  def teardown
-    NewRelic::Agent.shutdown
-    @stats_engine.clear_stats
-  end
-  def test_record_controller_metrics
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    advance_time(2)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    expected_values = { :call_count => 1, :total_call_time => 2.0 }
-    assert_metrics_recorded(
-      'Controller/test/index' => expected_values,
-      'HttpDispatcher' => expected_values
-    )
-  end
-  def test_record_apdex_metrics
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    advance_time(1.5)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    expected_values = { :apdex_f => 0, :apdex_t => 1, :apdex_s => 0 }
-    assert_metrics_recorded(
-      'Apdex/test/index' => expected_values,
-      'Apdex' => expected_values
-    )
-  end
-  def test_record_apdex_metrics_with_error
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    advance_time(1.5)
-    error = StandardError.new("boo")
-    @exit_payload[:exception] = error
-    NewRelic::Agent.notice_error(error)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    expected_values = { :apdex_f => 1, :apdex_t => 0, :apdex_s => 0 }
-    assert_metrics_recorded(
-      'Apdex/test/index' => expected_values,
-      'Apdex' => expected_values
-    )
-  end
-  def test_records_scoped_metrics_for_evented_child_txn
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    @subscriber.start('process_action.action_controller', :id, @entry_payload \
-                        .merge(:action => 'child', :path => '/child'))
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload \
-                         .merge(:action => 'child', :path => '/child'))
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    assert_metrics_recorded(
-      ['Nested/Controller/test/child', 'Controller/test/child'] => { :call_count => 1 }
-    )
-  end
-  def test_records_scoped_metrics_for_traced_child_txn
-    controller = TestController.new
-    controller.perform_action_with_newrelic_trace(:category => :controller,
-                                                  :name => 'index',
-                                                  :class_name => 'test') do
-      @subscriber.start('process_action.action_controller', :id, @entry_payload \
-                          .merge(:action => 'child', :path => '/child'))
-      @subscriber.finish('process_action.action_controller', :id, @exit_payload \
-                           .merge(:action => 'child', :path => '/child'))
-    end
-    assert_metrics_recorded(
-      ['Nested/Controller/test/child', 'Controller/test/child'] => { :call_count => 1 }
-    )
-  end
-  def test_sets_default_transaction_name_on_start
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    assert_equal 'Controller/test/index', NewRelic::Agent::Transaction.tl_current.best_name
-  ensure
-    @subscriber.finish('process_action.action_controller', :id, @entry_payload)
-  end
-  def test_sets_default_transaction_keeps_name_through_stop
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    txn = NewRelic::Agent::Transaction.tl_current
-    @subscriber.finish('process_action.action_controller', :id, @entry_payload)
-    assert_equal 'Controller/test/index', txn.best_name
-  end
-  def test_sets_transaction_name
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    NewRelic::Agent.set_transaction_name('something/else')
-    assert_equal 'Controller/something/else', NewRelic::Agent::Transaction.tl_current.best_name
-  ensure
-    @subscriber.finish('process_action.action_controller', :id, @entry_payload)
-  end
-  def test_sets_transaction_name_holds_through_stop
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    txn = NewRelic::Agent::Transaction.tl_current
-    NewRelic::Agent.set_transaction_name('something/else')
-    @subscriber.finish('process_action.action_controller', :id, @entry_payload)
-    assert_equal 'Controller/something/else', txn.best_name
-  end
-  def test_record_nothing_for_ignored_action
-    @entry_payload[:action] = 'ignored_action'
-    @exit_payload[:action] = 'ignored_action'
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    assert_metrics_not_recorded([
-      'Controller/test/ignored_action',
-      'Apdex/test/ignored_action',
-      'Apdex',
-      'HttpDispatcher'
-    ])
-  end
-  def test_record_no_apdex_metric_for_ignored_apdex_action
-    @entry_payload[:action] = 'ignored_apdex'
-    @exit_payload[:action] = 'ignored_apdex'
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    assert_metrics_recorded(['Controller/test/ignored_apdex', 'HttpDispatcher'])
-    assert_metrics_not_recorded(['Apdex', 'Apdex/test/ignored_apdex'])
-  end
-  def test_ignore_end_user
-    @entry_payload[:action] = 'ignored_enduser'
-    @exit_payload[:action] = 'ignored_enduser'
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    txn = NewRelic::Agent::Transaction.tl_current
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    assert txn.ignore_enduser?
-  end
-  def test_record_busy_time
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    advance_time(1)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    NewRelic::Agent::BusyCalculator.harvest_busy
-    assert_metrics_recorded('Instance/Busy' => { :call_count => 1, :total_call_time => 1.0 })
-  end
-  def test_creates_transaction
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    assert_equal('Controller/test/index',
-                 NewRelic::Agent.instance.transaction_sampler \
-                   .last_sample.transaction_name)
-    assert_equal('Controller/test/index',
-                 NewRelic::Agent.instance.transaction_sampler \
-                   .last_sample.root_node.called_nodes[0].metric_name)
-  end
-  def test_applies_txn_name_rules
-    rule_specs = [{'match_expression' => 'test', 'replacement' => 'taste'}]
-    with_transaction_renaming_rules(rule_specs) do
-      @subscriber.start('process_action.action_controller', :id, @entry_payload)
-      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    end
-    assert_metrics_recorded(['Controller/taste/index'])
-    assert_metrics_not_recorded(['Controller/test/index'])
-  end
-  def test_record_queue_time_metrics
-    app = lambda do |env|
-      @subscriber.start('process_action.action_controller', :id, @entry_payload)
-      advance_time(2)
-      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    end
-    t0 = Time.now
-    env = { 'HTTP_X_REQUEST_START' => (t0 - 5).to_f.to_s }
-    ::NewRelic::Rack::AgentHooks.new(app).call(env)
-    assert_metrics_recorded(
-      'WebFrontend/QueueTime' => {
-        :call_count => 1,
-        :total_call_time => 5.0
-      }
-    )
-  end
-  def test_dont_record_queue_time_if_no_header
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    assert_metrics_not_recorded('WebFrontend/QueueTime')
-  end
-  def test_dont_record_queue_time_in_nested_transaction
-    app = lambda do |env|
-      @subscriber.start('process_action.action_controller',  :id, @entry_payload)
-      @subscriber.start('process_action.action_controller',  :id, @entry_payload)
-      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    end
-    t0 = Time.now
-    env = { 'HTTP_X_REQUEST_START' => (t0 - 5).to_f.to_s }
-    ::NewRelic::Rack::AgentHooks.new(app).call(env)
-    assert_metrics_recorded(
-      'WebFrontend/QueueTime' => {
-        :call_count => 1,
-        :total_call_time => 5.0
-      }
-    )
-  end
-  def test_records_request_params_in_txn
-    with_config(:capture_params => true) do
-      @entry_payload[:params]['number'] = '666'
-      @subscriber.start('process_action.action_controller', :id, @entry_payload)
-      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    end
-    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-    assert_equal('666', attributes_for(sample, :agent)['request.parameters.number'])
-  end
-  def test_records_filtered_request_params_in_txn
-    with_config(:capture_params => true) do
-      @entry_payload[:params]['password'] = 'secret'
-      @subscriber.start('process_action.action_controller', :id, @entry_payload)
-      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    end
-    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-    assert_equal('[FILTERED]', attributes_for(sample, :agent)['request.parameters.password'])
-  end
-  def test_records_custom_parameters_in_txn
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    NewRelic::Agent.add_custom_attributes('number' => '666')
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-    assert_equal('666', attributes_for(sample, :custom)['number'])
-  end
-end if ::Rails::VERSION::MAJOR.to_i >= 4
-else
-  puts "Skipping tests in #{__FILE__} because Rails is unavailable"
-end

data/test/new_relic/agent/instrumentation/action_view_subscriber_test.rb DELETED Viewed

@@ -1,239 +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.
-if defined?(::Rails)
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-require 'new_relic/agent/instrumentation/action_view_subscriber'
-class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Minitest::Test
-  def setup
-    @subscriber = NewRelic::Agent::Instrumentation::ActionViewSubscriber.new
-    @stats_engine = NewRelic::Agent.instance.stats_engine
-  end
-  def teardown
-    NewRelic::Agent.instance.stats_engine.clear_stats
-  end
-  def test_records_metrics_for_simple_template
-    params = { :identifier => '/root/app/views/model/index.html.erb' }
-    t0 = Time.now
-    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
-    @subscriber.start('render_template.action_view', :id, params)
-    @subscriber.start('!render_template.action_view', :id,
-                      :virtual_path => 'model/index')
-    @subscriber.finish('!render_template.action_view', :id,
-                       :virtual_path => 'model/index')
-    @subscriber.finish('render_template.action_view', :id, params)
-    expected = { :call_count => 1, :total_call_time => 2.0 }
-    assert_metrics_recorded('View/model/index.html.erb/Rendering' => expected)
-  end
-  def test_records_metrics_for_simple_file
-    params = { :identifier => '/root/something.txt' }
-    t0 = Time.now
-    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
-    @subscriber.start('render_template.action_view', :id, params)
-    @subscriber.start('!render_template.action_view', :id,
-                      :virtual_path => nil)
-    @subscriber.finish('!render_template.action_view', :id,
-                       :virtual_path => nil)
-    @subscriber.finish('render_template.action_view', :id, params)
-    expected = { :call_count => 1, :total_call_time => 2.0 }
-    assert_metrics_recorded('View/file/Rendering' => expected)
-  end
-  def test_records_metrics_for_simple_inline
-    params = { :identifier => 'inline template' }
-    t0 = Time.now
-    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
-    @subscriber.start('render_template.action_view', :id, params)
-    @subscriber.start('!render_template.action_view', :id,
-                      :virtual_path => nil)
-    @subscriber.finish('!render_template.action_view', :id,
-                       :virtual_path => nil)
-    @subscriber.finish('render_template.action_view', :id, params)
-    expected = { :call_count => 1, :total_call_time => 2.0 }
-    assert_metrics_recorded('View/inline template/Rendering' => expected)
-  end
-  def test_records_metrics_for_simple_text
-    params = { :identifier => 'text template' }
-    t0 = Time.now
-    Time.stubs(:now).returns(t0, t0 + 2)
-    @subscriber.start('render_template.action_view', :id, params)
-    @subscriber.finish('render_template.action_view', :id, params)
-    expected = { :call_count => 1, :total_call_time => 2.0 }
-    assert_metrics_recorded('View/text template/Rendering' => expected)
-  end
-  def test_records_metrics_for_simple_partial
-    params = { :identifier => '/root/app/views/model/_form.html.erb' }
-    t0 = Time.now
-    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
-    @subscriber.start('render_partial.action_view', :id, params)
-    @subscriber.start('!render_template.action_view', :id,
-                      :virtual_path => 'model/_form')
-    @subscriber.finish('!render_template.action_view', :id,
-                       :virtual_path => 'model/_form')
-    @subscriber.finish('render_partial.action_view', :id, params)
-    expected = { :call_count => 1, :total_call_time => 2.0 }
-    assert_metrics_recorded('View/model/_form.html.erb/Partial' => expected)
-  end
-  def test_records_metrics_for_simple_collection
-    params = { :identifier => '/root/app/views/model/_user.html.erb' }
-    t0 = Time.now
-    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
-    @subscriber.start('render_collection.action_view', :id, params)
-    @subscriber.start('!render_template.action_view', :id,
-                      :virtual_path => 'model/_user')
-    @subscriber.finish('!render_template.action_view', :id,
-                       :virtual_path => 'model/_user')
-    @subscriber.finish('render_collection.action_view', :id, params)
-    expected = { :call_count => 1, :total_call_time => 2.0 }
-    assert_metrics_recorded('View/model/_user.html.erb/Partial' => expected)
-  end
-  def test_records_metrics_for_layout
-    t0 = Time.now
-    Time.stubs(:now).returns(t0, t0 + 2)
-    @subscriber.start('!render_template.action_view', :id,
-                      :virtual_path => 'layouts/application')
-    @subscriber.finish('!render_template.action_view', :id,
-                       :virtual_path => 'layouts/application')
-    expected = { :call_count => 1, :total_call_time => 2.0 }
-    assert_metrics_recorded('View/layouts/application/Rendering' => expected)
-  end
-  def test_records_scoped_metric
-    params = { :identifier => '/root/app/views/model/index.html.erb' }
-    in_transaction('test_txn') do
-      @subscriber.start('render_template.action_view', :id, params)
-      @subscriber.start('!render_template.action_view', :id,
-                        :virtual_path => 'model/index')
-      @subscriber.finish('!render_template.action_view', :id,
-                         :virtual_path => 'model/index')
-      @subscriber.finish('render_template.action_view', :id, params)
-    end
-    expected = { :call_count => 1 }
-    assert_metrics_recorded(
-      ['View/model/index.html.erb/Rendering', 'test_txn'] => expected
-    )
-  end
-  def test_records_nothing_if_tracing_disabled
-    params = { :identifier => '/root/app/views/model/_user.html.erb' }
-    NewRelic::Agent.disable_all_tracing do
-      @subscriber.start('render_collection.action_view', :id, params)
-      @subscriber.finish('render_collection.action_view', :id, params)
-    end
-    assert_metrics_not_recorded('View/model/_user.html.erb/Partial')
-  end
-  def test_creates_txn_node_for_simple_render
-    params = { :identifier => '/root/app/views/model/index.html.erb' }
-    in_transaction do
-      @subscriber.start('render_template.action_view', :id, params)
-      @subscriber.start('!render_template.action_view', :id,
-                        :virtual_path => 'model/index')
-      @subscriber.finish('!render_template.action_view', :id,
-                         :virtual_path => 'model/index')
-      @subscriber.finish('render_template.action_view', :id, params)
-    end
-    last_node = nil
-    sampler = NewRelic::Agent.instance.transaction_sampler
-    sampler.last_sample.root_node.each_node{|s| last_node = s }
-    NewRelic::Agent.shutdown
-    assert_equal('View/model/index.html.erb/Rendering',
-                 last_node.metric_name)
-  end
-  def test_creates_nested_partial_node_within_render_node
-    in_transaction do
-      @subscriber.start('render_template.action_view', :id,
-                        :identifier => 'model/index.html.erb')
-      @subscriber.start('!render_template.action_view', :id,
-                        :virtual_path => 'model/index')
-      @subscriber.start('render_partial.action_view', :id,
-                        :identifier => '/root/app/views/model/_list.html.erb')
-      @subscriber.start('!render_template.action_view', :id,
-                        :virtual_path => 'model/_list')
-      @subscriber.finish('!render_template.action_view', :id,
-                         :virtual_path => 'model/_list')
-      @subscriber.finish('render_partial.action_view', :id,
-                         :identifier => '/root/app/views/model/_list.html.erb')
-      @subscriber.finish('!render_template.action_view', :id,
-                           :virtual_path => 'model/index')
-      @subscriber.finish('render_template.action_view', :id,
-                         :identifier => 'model/index.html.erb')
-    end
-    sampler = NewRelic::Agent.instance.transaction_sampler
-    template_node = sampler.last_sample.root_node.called_nodes[0].called_nodes[0]
-    partial_node = template_node.called_nodes[0]
-    assert_equal('View/model/index.html.erb/Rendering',
-                 template_node.metric_name)
-    assert_equal('View/model/_list.html.erb/Partial',
-                 partial_node.metric_name)
-  end
-  def test_creates_nodes_for_each_in_a_collection_event
-    in_transaction do
-      @subscriber.start('render_collection.action_view', :id,
-                        :identifier => '/root/app/views/model/_list.html.erb',
-                        :count => 3)
-      @subscriber.start('!render_template.action_view', :id,
-                        :virtual_path => 'model/_list')
-      @subscriber.finish('!render_template.action_view', :id,
-                        :virtual_path => 'model/_list')
-      @subscriber.start('!render_template.action_view', :id,
-                        :virtual_path => 'model/_list')
-      @subscriber.finish('!render_template.action_view', :id,
-                        :virtual_path => 'model/_list')
-      @subscriber.start('!render_template.action_view', :id,
-                        :virtual_path => 'model/_list')
-      @subscriber.finish('!render_template.action_view', :id,
-                        :virtual_path => 'model/_list')
-      @subscriber.finish('render_collection.action_view', :id,
-                         :identifier => '/root/app/views/model/_list.html.erb',
-                         :count => 3)
-    end
-    sampler = NewRelic::Agent.instance.transaction_sampler
-    partial_nodes = sampler.last_sample.root_node.called_nodes[0].called_nodes
-    assert_equal 3, partial_nodes.size
-    assert_equal('View/model/_list.html.erb/Partial',
-                 partial_nodes[0].metric_name)
-  end
-end if ::Rails::VERSION::MAJOR.to_i >= 4
-else
-  puts "Skipping tests in #{__FILE__} because Rails is unavailable"
-end

data/test/new_relic/agent/instrumentation/active_job_test.rb DELETED Viewed

@@ -1,20 +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/instrumentation/active_job'
-module NewRelic::Agent::Instrumentation
-  class ActiveJobHelperTest < Minitest::Test
-    def test_rails_formatted_adapters_get_shortened
-      name = ActiveJobHelper.clean_adapter_name("ActiveJob::QueueAdapters::InlineAdapter")
-      assert_equal "ActiveJob::Inline", name
-    end
-    def test_unexpected_name_format
-      name = ActiveJobHelper.clean_adapter_name("Not::AnExpected::Adapter")
-      assert_equal "Not::AnExpected::Adapter", name
-    end
-  end
-end

data/test/new_relic/agent/instrumentation/active_record_helper_test.rb DELETED Viewed

@@ -1,77 +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/instrumentation/active_record_helper'
-module NewRelic::Agent::Instrumentation
-  class ActiveRecordHelperTest < Minitest::Test
-    def test_metrics_for_find
-      metrics = ActiveRecordHelper.metrics_for('Namespace::Model Load', nil, nil)
-      expected = expected_statement_metrics("find", "Namespace::Model/find")
-      assert_equal(expected, metrics)
-    end
-    def test_metrics_for_destroy
-      metrics = ActiveRecordHelper.metrics_for('Model Destroy', nil, nil)
-      expected = expected_statement_metrics("destroy", "Model/destroy")
-      assert_equal(expected, metrics)
-    end
-    def test_metrics_for_create
-      metrics = ActiveRecordHelper.metrics_for('Model Create', nil, nil)
-      expected = expected_statement_metrics("create", "Model/create")
-      assert_equal(expected, metrics)
-    end
-    def test_metrics_for_update
-      metrics = ActiveRecordHelper.metrics_for('Model Update', nil, nil)
-      expected = expected_statement_metrics("update", "Model/update")
-      assert_equal(expected, metrics)
-    end
-    def test_metric_for_name_columns
-      metrics = ActiveRecordHelper.metrics_for('Model Columns', nil, nil)
-      expected = expected_statement_metrics("columns", "Model/columns")
-      assert_equal(expected, metrics)
-    end
-    def test_metric_with_product_name_from_adapter
-      metrics = ActiveRecordHelper.metrics_for('Model Load', nil, "mysql")
-      expected = expected_statement_metrics("find", "Model/find", "MySQL")
-      assert_equal(expected, metrics)
-    end
-    def test_metrics_from_sql
-      metrics = ActiveRecordHelper.metrics_for('invalid', "SELECT * FROM boo", nil)
-      expected = expected_operation_metrics("select")
-      assert_equal(expected, metrics)
-    end
-    def test_metric_for_name_with_integer_returns_nil
-      metrics = ActiveRecordHelper.metrics_for(1, '', nil)
-      expected = expected_operation_metrics("other")
-      assert_equal(expected, metrics)
-    end
-    def test_rollup_metrics_for_is_deprecated
-      NewRelic::Agent::Deprecator.expects(:deprecate)
-      result = ActiveRecordHelper.rollup_metrics_for("boo")
-      assert_equal ["Datastore/allOther", "Datastore/all"], result
-    end
-    def expected_statement_metrics(operation, statement, product = "ActiveRecord")
-      ["Datastore/statement/#{product}/#{statement}"] +
-        expected_operation_metrics(operation, product)
-    end
-    def expected_operation_metrics(operation, product = "ActiveRecord")
-      ["Datastore/operation/#{product}/#{operation}",
-        "Datastore/#{product}/allOther",
-        "Datastore/#{product}/all",
-        "Datastore/allOther",
-        "Datastore/all"]
-    end
-  end
-end