newrelic_plugin 1.0.3 → 1.2.1

data/test/newrelic_platform_binding/connection_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+require 'logger'
+
+class ConnectionTest < Minitest::Test
+
+  def setup
+    @context = NewRelic::Binding::Context.new('license_key')
+    @connection = NewRelic::Binding::Connection.new(@context)
+    if NewRelic::Binding::Config.ssl_supported?
+      @endpoint = 'https://platform-api.newrelic.com'
+    else
+      @endpoint = 'http://platform-api.newrelic.com'
+    end
+  end
+
+  def test_deliver_successful
+    FakeWeb.register_uri(:post, "#{@endpoint}/platform/v1/metrics", :body => '{"status":"ok"}', :status => [200, "Success"])
+    ::Logger.expects(:info).never
+    assert_equal true, @connection.send_request('data')
+  end
+
+  def test_deliver_error_codes
+    FakeWeb.register_uri(:post, "#{@endpoint}/platform/v1/metrics", :body => '{"error":"Missing metric data"}', :status => [200, "Success"])
+    NewRelic::Logger.expects(:error).with("FAILED[200] <#{@endpoint}/platform/v1/metrics>: Missing metric data")
+    assert_equal false, @connection.send_request('data')
+  end
+
+  def test_deliver_disabled_by_new_relic
+    FakeWeb.register_uri(:post, "#{@endpoint}/platform/v1/metrics", :body => 'DISABLE_NEW_RELIC', :status => [403, 'Unauthorized'])
+    NewRelic::Logger.expects(:fatal).with("Agent has been disabled remotely by New Relic")
+    NewRelic::Binding::Connection.any_instance.expects(:abort)
+    @connection.send_request('data')
+  end
+
+  def test_deliver_no_response
+    Net::HTTP.any_instance.expects(:request).returns(nil)
+    NewRelic::Logger.expects(:error).with("FAILED: No response")
+    assert_equal false, @connection.send_request('data')
+  end
+
+  def test_deliver_no_data_returned
+    FakeWeb.register_uri(:post, "#{@endpoint}/platform/v1/metrics", :body => '', :status => [204, "No Content"])
+    NewRelic::Logger.expects(:error).with("FAILED[204] <#{@endpoint}/platform/v1/metrics>: no data returned")
+    assert_equal false, @connection.send_request('data')
+  end
+
+  def test_deliver_non_json_response_body_unexpected_response_code
+    FakeWeb.register_uri(:post, "#{@endpoint}/platform/v1/metrics", :body => 'test', :status => [203, "Non-Authoritative Information"])
+    JSON::ParserError.any_instance.stubs(:message => 'parse error')
+    NewRelic::Logger.expects(:error).with("FAILED[203] <#{@endpoint}/platform/v1/metrics>: Could not parse response: parse error")
+    assert_equal false, @connection.send_request('data')
+  end
+
+  def test_deliver_non_json_response_body_success_response_code
+    FakeWeb.register_uri(:post, "#{@endpoint}/platform/v1/metrics", :body => 'test', :status => [200, "Success"])
+    JSON::ParserError.any_instance.stubs(:message => 'parse error')
+    NewRelic::Logger.expects(:error).with("FAILED[200] <#{@endpoint}/platform/v1/metrics>: Could not parse response: parse error")
+    assert_equal false, @connection.send_request('data')
+  end
+
+  def test_deliver_service_unavailable
+    FakeWeb.register_uri(:post, "#{@endpoint}/platform/v1/metrics", :body => 'test', :status => [503, "Service Unavailable"])
+    NewRelic::Logger.expects(:warn).with("Collector temporarily unavailable. Continuing.")
+    assert_equal false, @connection.send_request('data')
+  end
+
+end

data/test/newrelic_platform_binding/context_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class ContextTest < Minitest::Test
+
+  def setup
+    @context = NewRelic::Binding::Context.new('license_key')
+  end
+
+  def test_that_create_component_returns_created_appointment
+    assert_equal NewRelic::Binding::Component, @context.create_component('name', 'com.test').class
+  end
+
+  def test_that_get_request_returns_a_request
+    assert_equal NewRelic::Binding::Request, @context.get_request.class
+  end
+
+  def test_that_get_request_returns_the_same_request_if_the_request_has_not_been_delivered
+    request = @context.get_request
+    assert_equal request, @context.get_request
+  end
+
+  def test_that_get_request_returns_a_new_request_if_the_aggregation_limit_is_reached
+    Timecop.freeze(Time.now - 25 * 60)
+    context = NewRelic::Binding::Context.new('license_key')
+    request = context.get_request
+    Timecop.return
+    assert request != context.get_request
+  end
+
+  def test_that_get_request_returns_a_new_request_if_the_request_has_been_delivered
+    request = @context.get_request
+    request.expects(:delivered?).returns(true)
+    assert request != @context.get_request
+  end
+end

data/test/newrelic_platform_binding/logger_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class LoggerTest < Minitest::Test
+
+  def setup
+    @log = NewRelic::Logger.instance_variable_get(:@log)
+  end
+
+  def test_debug_calls_log_debug
+    @log.expects(:debug).with('test')
+    NewRelic::Logger.debug('test')
+  end
+
+  def test_info_calls_log_info
+    @log.expects(:info).with('test')
+    NewRelic::Logger.info('test')
+  end
+
+  def test_warn_calls_log_warn
+    @log.expects(:warn).with('test')
+    NewRelic::Logger.warn('test')
+  end
+
+  def test_error_calls_log_error
+    @log.expects(:error).with('test')
+    NewRelic::Logger.error('test')
+  end
+
+  def test_fatal_calls_log_fatal
+    @log.expects(:fatal).with('test')
+    NewRelic::Logger.fatal('test')
+  end
+end

data/test/newrelic_platform_binding/metric_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class MetricTest < Minitest::Test
+
+  def setup
+    @component = NewRelic::Binding::Component.new('name', 'com.test')
+  end
+
+  def test_component
+    assert_equal @component, initialize_metric.component
+  end
+
+  def test_initialize_without_options_does_not_trigger_options_warning
+    NewRelic::Logger.expects(:warn).never
+    NewRelic::Binding::Metric.new(@component, 'Component/Test/rate[units]', '10')
+  end
+
+  def test_value
+    assert_equal 10, initialize_metric.value
+  end
+
+  def test_count_without_options
+    assert_equal 1, initialize_metric.count
+  end
+
+  def test_min_without_options
+    assert_equal 10, initialize_metric.min
+  end
+
+  def test_max_without_options
+    assert_equal 10, initialize_metric.max
+  end
+
+  def test_sum_of_squares_without_options
+    assert_equal 10*10, initialize_metric.sum_of_squares
+  end
+
+  def test_count_with_only_count_option_set
+    NewRelic::Logger.expects(:warn).with('Metric Component/Test/rate[units] count, min, max, and sum_of_squares are all required if one is set, falling back to value only')
+    assert_equal 1, initialize_metric(:count => 2).count
+  end
+
+  def test_min_with_only_min_option_set
+    NewRelic::Logger.expects(:warn).with('Metric Component/Test/rate[units] count, min, max, and sum_of_squares are all required if one is set, falling back to value only')
+    assert_equal 10, initialize_metric(:min => 5).min
+  end
+
+  def test_max_with_only_max_option_set
+    NewRelic::Logger.expects(:warn).with('Metric Component/Test/rate[units] count, min, max, and sum_of_squares are all required if one is set, falling back to value only')
+    assert_equal 10, initialize_metric(:max => 15).max
+  end
+
+  def test_sum_of_squares_with_only_sum_of_squares_option_set
+    NewRelic::Logger.expects(:warn).with('Metric Component/Test/rate[units] count, min, max, and sum_of_squares are all required if one is set, falling back to value only')
+    assert_equal 100, initialize_metric(:sum_of_squares => 400).sum_of_squares
+  end
+
+  def test_hash
+    assert_equal expected_hash, initialize_metric(:count => 2, :max => 15, :min => 5, :sum_of_squares => 250).to_hash
+  end
+
+  def test_initialize_with_string_for_value
+    metric = NewRelic::Binding::Metric.new(@component, 'Component/Test/rate[units]', '10')
+    hash = { 'Component/Test/rate[units]' => [10.0, 1, 10.0, 10.0, 100.0] }
+    assert_equal hash, metric.to_hash
+  end
+
+  def test_initialize_with_string_for_value_and_options
+    metric = NewRelic::Binding::Metric.new(@component, 'Component/Test/rate[units]', '10', :count => '2', :max => '15', :min => '5', :sum_of_squares => '250')
+    hash = { 'Component/Test/rate[units]' => [10.0, 2, 5.0, 15.0, 250.0] }
+    assert_equal hash, metric.to_hash
+  end
+
+  def test_aggregate_with_value
+    metric = initialize_metric()
+    metric2 = NewRelic::Binding::Metric.new(@component, 'Component/Test/rate[units]', 15)
+    metric.aggregate(metric2)
+    hash = { 'Component/Test/rate[units]' => [25.0, 2, 10.0, 15.0, 325.0] }
+    assert_equal hash, metric.to_hash
+  end
+
+  def test_aggregate_with_value_and_options
+    metric = initialize_metric()
+    metric2 = NewRelic::Binding::Metric.new(@component, 'Component/Test/rate[units]', '20', :count => '2', :max => '15', :min => '5', :sum_of_squares => '250')
+    metric.aggregate(metric2)
+    hash = { 'Component/Test/rate[units]' => [30.0, 3, 5.0, 15.0, 350.0] }
+    assert_equal hash, metric.to_hash
+  end
+
+  def initialize_metric(options = {})
+    NewRelic::Binding::Metric.new(@component, 'Component/Test/rate[units]', 10, options)
+  end
+
+  def expected_hash
+    { 'Component/Test/rate[units]' => [10, 2, 5, 15, 250] }
+  end
+end

data/test/newrelic_platform_binding/request_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+require 'fakeweb'
+
+class RequestTest < Minitest::Test
+
+  def setup
+    FakeWeb.allow_net_connect = false
+    @context = NewRelic::Binding::Context.new('license_key')
+  end
+
+  def test_initialization
+    request = NewRelic::Binding::Request.new(@context)
+    assert_equal @context, request.context
+  end
+
+  def test_add_metric_returns_a_metric
+    metric_setup
+    @metric = @request.add_metric(@component, 'Component/test_name', 10)
+    assert_equal NewRelic::Binding::Metric, @metric.class
+  end
+
+  def test_add_metric_does_not_aggregate_when_metric_does_not_already_exist
+    metric_setup
+    NewRelic::Binding::Metric.any_instance.expects(:aggregate).never
+    @metric = @request.add_metric(@component, 'Component/test_name', 10)
+  end
+
+  def test_add_metric_aggregates_when_metric_already_exists
+    metric_setup
+    @metric = @request.add_metric(@component, 'Component/test_name', 10)
+    @metric.expects(:aggregate)
+    @request.add_metric(@component, 'Component/test_name', 10)
+  end
+
+  def test_find_metric_when_component_does_not_exist_yet
+    metric_setup
+    metric_name = 'Component/test_name'
+    assert_equal nil, @request.send(:find_metric, @component, metric_name)
+  end
+
+  def test_find_metric_when_metric_does_not_exist
+    metric_setup
+    metric_name = 'Component/test_name'
+    metric = @request.add_metric(@component, metric_name, 10)
+    assert_equal nil, @request.send(:find_metric, @component, metric_name + '/foo')
+  end
+
+  def test_find_metric_when_metric_already_exists
+    metric_setup
+    metric_name = 'Component/test_name'
+    metric = @request.add_metric(@component, metric_name, 10)
+    assert_equal metric, @request.send(:find_metric, @component, metric_name)
+  end
+
+  def test_before_adding_metric_the_requests_metrics_data_structure_is_empty
+    metric_setup
+    assert_equal Hash.new, @request.instance_variable_get(:@metrics)
+  end
+
+  def test_after_adding_metric_the_requests_metrics_data_structure_contains_expected_data
+    metric_setup
+    @metric = @request.add_metric(@component, 'Component/test_name', 10)
+    expected_hash = { 'namecom.test' => [@metric] }
+    assert_equal expected_hash, @request.instance_variable_get(:@metrics)
+  end
+
+  def test_build_request_data_structure
+    metric_setup
+    @request.add_metric(@component, 'Component/test/first[units]', 1)
+    @request.add_metric(@component, 'Component/test/second[units]', 2)
+    assert_equal example_hash, @request.send(:build_request_data_structure)
+  end
+
+  def test_build_request_data_structure_when_component_has_no_metrics
+    metric_setup
+    ::NewRelic::Logger.expects(:warn).with("Component with name \"name\" and guid \"com.test\" had no metrics")
+    @request.send(:build_request_data_structure)
+  end
+
+  def test_delivered_returns_false_after_initialization
+    metric_setup
+    assert_equal false, @request.delivered?
+  end
+
+  def test_delivered_returns_true_after_successful_delivery
+    metric_setup
+    Timecop.freeze(Time.now)
+    ::NewRelic::Binding::Connection.any_instance.expects(:send_request).returns(true)
+    @context.expects(:last_request_delivered_at=).with(Time.now)
+    @request.deliver
+    assert_equal true, @request.delivered?
+    Timecop.return
+  end
+
+  def test_delivered_returns_false_after_unsuccessful_delivery
+    metric_setup
+    ::NewRelic::Binding::Connection.any_instance.expects(:send_request).returns(false)
+    @request.deliver
+    assert_equal false, @request.delivered?
+  end
+
+  def example_hash
+    {
+      'agent' => {
+        'version' => '1.0.0'
+      },
+      'components' => [
+        {
+          'name' => 'name',
+          'guid' => 'com.test',
+          'duration' => 60,
+          'metrics' => {
+             'Component/test/first[units]' => [1, 1, 1, 1, 1],
+             'Component/test/second[units]' => [2, 1, 2, 2, 4]
+          }
+        }
+      ]
+    }
+  end
+
+  def metric_setup
+    @context.version = '1.0.0'
+    @component = @context.create_component('name', 'com.test')
+    @request = @context.get_request()
+  end
+
+end

data/test/newrelic_plugin/agent_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+class AgentTest < Minitest::Test
+
+  def setup
+    @agent_class = TestingAgent::Agent.dup
+    @context = NewRelic::Binding::Context.new('license_key')
+  end
+
+  def test_agent_guid_should_set_guid
+    @agent_class.class_eval do
+      agent_guid '12234'
+    end
+    agent = @agent_class.new(@context)
+    assert_equal '12234', agent.class.guid
+  end
+
+  def test_agent_guid_should_raise_if_guid_is_set_to_nil
+    assert_raises RuntimeError do
+      @agent_class.class_eval do
+        agent_guid nil
+      end
+    end
+  end
+
+  def test_agent_guid_should_raise_if_guid_is_set_to_empty_string
+    assert_raises RuntimeError do
+      @agent_class.class_eval do
+        agent_guid ""
+      end
+    end
+  end
+
+  def test_guid_should_return_instance_guid
+    agent = @agent_class.new(@context)
+    agent.instance_variable_set(:@guid, 'test')
+    assert_equal 'test', agent.guid
+  end
+
+  def test_guid_should_return_class_guid
+    @agent_class.class_eval do
+      @guid = '123'
+    end
+    agent = @agent_class.new(@context)
+    assert_equal '123', agent.guid
+  end
+
+  def test_agent_version_should_set_version
+    @agent_class.class_eval do
+      agent_version '0.0.1'
+    end
+    agent = @agent_class.new(@context)
+    assert_equal '0.0.1', agent.class.version
+  end
+
+  def test_agent_class_should_return_class_version
+    @agent_class.class_eval do
+      @version = '1.2.3'
+    end
+    agent = @agent_class.new(@context)
+    assert_equal '1.2.3', agent.version
+  end
+
+  def test_agent_human_labels_should_set_class_label
+    @agent_class.class_eval do
+      agent_human_labels('Testing Agent') { 'Testing Agent block' }
+    end
+    agent = @agent_class.new(@context)
+    assert_equal 'Testing Agent', agent.class.label
+  end
+
+  def test_agent_human_labels_should_set_instance_label_proc
+    @agent_class.class_eval do
+      agent_human_labels('Testing Agent') { 'Testing Agent block' }
+    end
+    agent = @agent_class.new(@context)
+    assert_equal "Testing Agent block", agent.class.instance_label_proc.call
+  end
+
+  def test_no_config_required_should_set_class_no_config_required
+    @agent_class.class_eval do
+      agent_human_labels('Testing Agent') { 'Testing Agent block' }
+    end
+    agent = @agent_class.new(@context)
+    assert_equal true, agent.class.no_config_required
+  end
+
+  def test_config_required_should_return_false_when_class_no_config_required_true
+    @agent_class.class_eval do
+      @no_config_required = true
+    end
+    agent = @agent_class.new(@context)
+    assert_equal false, agent.class.config_required?
+  end
+  def test_config_required_should_return_true_when_class_no_config_required_false
+    @agent_class.class_eval do
+      @no_config_required = false
+    end
+    agent = @agent_class.new(@context)
+    assert_equal true, agent.class.config_required?
+  end
+  def test_config_required_should_return_true_when_class_no_config_required_is_not_set
+    @agent_class.class_eval do
+    end
+    agent = @agent_class.new(@context)
+    assert_equal true, agent.class.config_required?
+  end
+
+  def test_agent_config_options_should_set_class_config_options_list_if_empty
+    @agent_class.class_eval do
+      agent_config_options(:test, 'foo', 'bar')
+    end
+    @agent = @agent_class.new(@context)
+    assert_equal [:test, 'foo', 'bar'], @agent.class.config_options_list
+  end
+
+  def test_agent_config_options_should_add_to_existing_config_options_list
+    @agent_class.class_eval do
+      attr_accessor 'foobar'
+      @config_options_list = ['foobar']
+      agent_config_options(:test, 'foo', 'bar')
+    end
+
+    @agent = @agent_class.new(@context)
+    assert_equal ['foobar', :test, 'foo', 'bar'], @agent.class.config_options_list
+  end
+end