newrelic_rpm 3.12.0.288 → 9.10.2

data/test/new_relic/data_container_tests.rb

@@ -1,76 +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.
-
-# To use this module to test your new data container, implement the following
-# methods before including it:
-#
-# create_container -> create an instance of your data container class
-# populate_container(container, n) -> populate the container with n items
-#
-# If your container can only hold a fixed number of data items, you can also
-# implement #max_data_items to return the number of data items that it should be
-# populated with for the purposes of testing.
-
-module NewRelic
-  module BasicDataContainerMethodTests
-    def test_should_respond_to_required_methods
-      c = create_container
-      assert c.respond_to?(:harvest!)
-      assert c.respond_to?(:reset!)
-      assert c.respond_to?(:merge!)
-    end
-  end
-
-  module BasicDataContainerTests
-    include BasicDataContainerMethodTests
-
-    def num_data_items
-      self.respond_to?(:max_data_items) ? max_data_items : 5
-    end
-
-    def test_harvest_should_return_all_data_items
-      c = create_container
-      populate_container(c, num_data_items)
-      results = c.harvest!
-      assert_equal(num_data_items, results.size)
-    end
-
-    def test_calling_harvest_again_should_not_return_items_again
-      c = create_container
-      populate_container(c, num_data_items)
-
-      c.harvest! # clears container
-      results = c.harvest!
-      assert_equal(0, results.size)
-    end
-
-    def test_calling_harvest_after_re_populating_works
-      container = create_container
-      populate_container(container, num_data_items)
-      assert_equal(num_data_items, container.harvest!.size)
-
-      populate_container(container, num_data_items)
-      assert_equal(num_data_items, container.harvest!.size)
-    end
-  end
-
-  module DataContainerTests
-    include BasicDataContainerTests
-
-    def test_reset_should_clear_stored_items
-      c = create_container
-      populate_container(c, 5)
-      c.reset!
-      assert_equal(0, c.harvest!.size)
-    end
-
-    def test_merge_should_re_integrate_items
-      c = create_container
-      populate_container(c, 5)
-      c.merge!(c.harvest!)
-      results = c.harvest!
-      assert_equal(5, results.size)
-    end
-  end
-end

data/test/new_relic/dependency_detection_test.rb

@@ -1,155 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
-
-class DependencyDetectionTest < Minitest::Test
-
-  def setup
-    @original_items = DependencyDetection.items
-    DependencyDetection.items = []
-  end
-
-  def teardown
-    DependencyDetection.items = @original_items
-  end
-
-  def test_passes_dependency
-    executed = false
-
-    DependencyDetection.defer do
-      depends_on { true }
-      executes   { executed = true }
-    end
-    DependencyDetection.detect!
-
-    assert executed
-  end
-
-  def test_fails_dependency
-    executed = false
-
-    DependencyDetection.defer do
-      depends_on { true }
-      depends_on { false }
-      executes   { executed = true }
-    end
-    DependencyDetection.detect!
-
-    assert !executed
-  end
-
-  def test_short_circuits_on_failure
-    executed = false
-
-    # Requires that depends_on would let failures pass through, which it does
-    DependencyDetection.defer do
-      depends_on { false }
-      depends_on { raise "OH NOES"}
-      executes   { executed = true }
-    end
-    DependencyDetection.detect!
-
-    assert !executed
-  end
-
-  def test_named_disabling_defaults_to_allowed
-    executed = false
-
-    DependencyDetection.defer do
-      named :testing
-      executes { executed = true }
-    end
-    DependencyDetection.detect!
-
-    assert executed
-  end
-
-  def test_named_disabling_allows_with_explicit_value
-    executed = false
-
-    DependencyDetection.defer do
-      named :testing
-      executes { executed = true }
-    end
-
-    with_config(:disable_testing => false) do
-      DependencyDetection.detect!
-    end
-
-    assert executed
-  end
-
-  def test_named_disabling
-    executed = false
-
-    DependencyDetection.defer do
-      named :testing
-      executes { executed = true }
-    end
-
-    with_config(:disable_testing => true) do
-      DependencyDetection.detect!
-    end
-
-    assert !executed
-  end
-
-  def test_named_disabling_with_instance_variable
-    executed = false
-
-    DependencyDetection.defer do
-      @name = :testing
-      executes { executed = true }
-    end
-
-    with_config(:disable_testing => true) do
-      DependencyDetection.detect!
-    end
-
-    assert !executed
-  end
-
-  def test_exception_during_depends_on_check_doesnt_propagate
-    DependencyDetection.defer do
-      named :something_exceptional
-      depends_on { raise "Oops" }
-    end
-
-    DependencyDetection.detect!
-
-    assert_falsy( DependencyDetection.items.first.executed )
-  end
-
-
-  def test_exception_during_execution_doesnt_propagate
-    ran_second_block = false
-
-    DependencyDetection.defer do
-      named :something_exceptional
-      executes { raise "Ack!" }
-      executes { ran_second_block = true }
-    end
-
-    DependencyDetection.detect!
-
-    assert_truthy( DependencyDetection.items.first.executed )
-    assert_falsy( ran_second_block )
-  end
-
-  def test_defer_should_be_idempotent_when_given_same_name
-    run_count = 0
-
-    2.times do
-      DependencyDetection.defer do
-        named :foobar
-        executes { run_count += 1 }
-      end
-    end
-
-    DependencyDetection.detect!
-
-    assert_equal(1, run_count)
-  end
-end

data/test/new_relic/dispatcher_test.rb

@@ -1,59 +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'))
-
-# Test logic around detecting or configuring dispatcher
-class DispatcherTest < Minitest::Test
-
-  def setup
-    NewRelic::Agent.shutdown
-    NewRelic::Agent.reset_config
-  end
-
-  def teardown
-    NewRelic::Agent.reset_config
-    NewRelic::Control.reset
-  end
-
-  def assert_dispatcher_reported_to_environment_report(dispatcher)
-    assert_equal dispatcher.to_s, NewRelic::EnvironmentReport.new["Dispatcher"]
-  end
-
-  def test_detects_dispatcher_via_loaded_libraries
-    class << self
-      module ::PhusionPassenger
-      end
-    end
-    assert_equal :passenger, NewRelic::Agent.config[:dispatcher]
-    assert_dispatcher_reported_to_environment_report :passenger
-  ensure
-    Object.send(:remove_const, :PhusionPassenger)
-  end
-
-  def test_detects_dispatcher_via_ENV_NEW_RELIC_DISPATCHER
-    ENV['NEW_RELIC_DISPATCHER'] = "foobared"
-    NewRelic::Agent.reset_config
-    assert_equal :foobared, NewRelic::Agent.config[:dispatcher]
-    assert_dispatcher_reported_to_environment_report :foobared
-  ensure
-    ENV['NEW_RELIC_DISPATCHER'] = nil
-  end
-
-  def test_detects_dispatcher_via_ENV_NEWRELIC_DISPATCHER
-    ENV['NEWRELIC_DISPATCHER'] = "bazbang"
-    NewRelic::Agent.reset_config
-    assert_equal :bazbang, NewRelic::Agent.config[:dispatcher]
-    assert_dispatcher_reported_to_environment_report :bazbang
-  ensure
-    ENV['NEWRELIC_DISPATCHER'] = nil
-  end
-
-  def test_detects_dispatcher_based_on_arguments_to_manual_start
-    NewRelic::Agent.manual_start(:dispatcher   => :resque)
-    assert_equal :resque, NewRelic::Agent.config[:dispatcher]
-    assert_dispatcher_reported_to_environment_report :resque
-  end
-
-end

data/test/new_relic/environment_report_test.rb

@@ -1,107 +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/environment_report'
-
-class EnvironmentReportTest < Minitest::Test
-  def setup
-    @old_logic = ::NewRelic::EnvironmentReport.registered_reporters.dup
-    @report = ::NewRelic::EnvironmentReport.new
-  end
-
-  def teardown
-    ::NewRelic::EnvironmentReport.registered_reporters = @old_logic
-  end
-
-  def test_converts_to_array
-    ::NewRelic::EnvironmentReport.report_on("something"){"awesome"}
-    data = Array(::NewRelic::EnvironmentReport.new)
-    expected = ["something", "awesome"]
-    assert data.include?(expected), "expected to find #{expected} in #{data.inspect}"
-  end
-
-  def test_register_a_value_to_report_on
-    ::NewRelic::EnvironmentReport.report_on("What time is it?") do
-      "beer-o-clock"
-    end
-    assert_equal 'beer-o-clock', ::NewRelic::EnvironmentReport.new["What time is it?"]
-  end
-
-  def test_report_on_handles_errors_gracefully
-    ::NewRelic::EnvironmentReport.report_on("What time is it?") do
-      raise ArgumentError, "woah! something blew up"
-    end
-    assert_nil ::NewRelic::EnvironmentReport.new["What time is it?"]
-  end
-
-  def test_it_does_not_set_keys_for_nil_values
-    ::NewRelic::EnvironmentReport.report_on("What time is it?") do
-      nil
-    end
-    assert ! NewRelic::EnvironmentReport.new.data.has_key?("What time is it?")
-  end
-
-  def test_can_set_an_environment_value_directly
-    @report['My Value'] = "so awesome!!"
-    assert_equal "so awesome!!", @report['My Value']
-  end
-
-  def test_it_knows_what_gems_are_in_the_environment
-    assert(@report['Gems'].size > 5, "Expected at least 5 gems in #{@report['Gems'].inspect}")
-    rake = @report['Gems'].detect{|s| s.include? 'rake'}
-    assert_match(/^rake\([\d\.]+\)$/, rake)
-  end
-
-  def test_gathers_ruby_version
-    assert_equal RUBY_VERSION, @report['Ruby version']
-  end
-
-  def test_gathers_openssl_version
-    refute_nil @report['OpenSSL version']
-  end
-
-  def test_gathers_system_info
-    NewRelic::Agent::SystemInfo.stubs({
-      :num_logical_processors => 8,
-      :processor_arch         => 'x86_64',
-      :os_version             => 'WiggleOS 1.1.1',
-      :ruby_os_identifier     => 'wiggleos'
-    })
-    report = ::NewRelic::EnvironmentReport.new
-    assert_equal(8, report['Logical Processors'])
-    assert_equal('x86_64', report['Arch'])
-    assert_equal('WiggleOS 1.1.1', report['OS version'])
-    assert_equal('wiggleos', report['OS'])
-  end
-
-  def test_has_logic_for_keys
-    [
-      "Gems",
-      "Plugin List",
-      "Ruby version",
-      "Ruby description",
-      "Ruby platform",
-      "Ruby patchlevel",
-      'JRuby version',
-      'Java VM version',
-      'Logical Processors',
-      'Physical Cores',
-      'Database adapter',
-      'Framework',
-      'Dispatcher',
-      'Environment',
-      'Arch',
-      'OS version',
-      'OS',
-      'Rails Env',
-      'Rails version',
-      'Rails threadsafe',
-      'OpenSSL version',
-    ].each do |key|
-      assert NewRelic::EnvironmentReport.registered_reporters.has_key?(key), "Expected logic for #{key.inspect} in EnvironmentReport."
-    end
-  end
-end

data/test/new_relic/evil_server.rb

@@ -1,55 +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.
-
-# This is a simple TCP server that binds to an ephemeral port, accepts
-# incoming connections on that port, and then closes those connections
-# immediately thereafter.
-#
-# Its purpose is to emulate a misbehaving HTTP server (or flaky network
-# connection) by closing the TCP connection without sending an HTTP response.
-
-require 'socket'
-
-module NewRelic
-  class EvilServer
-    attr_reader :port, :requests
-
-    def initialize
-      @requests = []
-    end
-
-    def should_run?
-      @state == :running
-    end
-
-    def stop
-      @state = :stopped
-
-      # just a lazy way of just forcing the server to wakeup from accept
-      TCPSocket.open("localhost", @port).close rescue nil
-
-      @thread.join
-      @thread = nil
-    end
-
-    def start
-      return if @thread && @thread.alive?
-      @requests = []
-      @server = TCPServer.new(0)
-      @port = @server.addr[1]
-      @state = :running
-      @thread = Thread.new { run }
-      @thread.abort_on_exception = true
-    end
-
-    def run
-      loop do
-        client = @server.accept
-        @requests << client.readpartial(1024) if should_run?
-        client.close
-        break unless should_run?
-      end
-    end
-  end
-end