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/event_aggregator_test.rb DELETED Viewed

@@ -1,178 +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 File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
-require 'new_relic/agent/event_aggregator'
-module NewRelic
-  module Agent
-    class EventAggregatorTest < Minitest::Test
-      class TestAggregator < EventAggregator
-        named :TestAggregator
-        capacity_key :cap_key
-        enabled_key :enabled_key
-        attr_reader :buffer
-        def append item
-          @buffer.append item
-          notify_if_full
-        end
-      end
-      def setup
-        NewRelic::Agent.config.add_config_for_testing(
-          :cap_key => 100,
-          :enabled_key => true
-        )
-        @aggregator = TestAggregator.new
-      end
-      def create_container
-        @aggregator
-      end
-      def populate_container(container, n)
-        n.times { |i| container.append i }
-      end
-      include NewRelic::DataContainerTests
-      def test_it_has_a_name
-        assert_equal 'TestAggregator', TestAggregator.named
-      end
-      def test_enabled_relects_config_value
-        assert @aggregator.enabled?, "Expected enabled? to be true"
-        with_config :enabled_key => false do
-          refute @aggregator.enabled?, "Expected enabled? to be false"
-        end
-      end
-      def test_after_harvest_invoked_with_report
-        metadata = {:meta => true}
-        @aggregator.buffer.stubs(:metadata).returns(metadata)
-        @aggregator.expects(:after_harvest).with(metadata)
-        @aggregator.harvest!
-      end
-      def test_notifies_full
-        expects_logging :debug, includes("TestAggregator capacity of 5 reached")
-        with_config :cap_key => 5 do
-          5.times { |i| @aggregator.append i}
-        end
-      end
-      def test_notifies_full_only_once
-        with_config :cap_key => 5 do
-          msg = "TestAggregator capacity of 5 reached"
-          # this will trigger a message to be logged
-          5.times { |i| @aggregator.append i}
-          # we expect subsequent appends not to trigger logging
-          expects_logging :debug, Not(includes(msg))
-          3.times {@aggregator.append 'no logs'}
-        end
-      end
-      def test_notifies_full_resets_after_harvest
-        msg = "TestAggregator capacity of 5 reached"
-        expects_logging :debug, includes(msg)
-        with_config :cap_key => 5 do
-          5.times { |i| @aggregator.append i}
-        end
-        @aggregator.harvest!
-        expects_logging :debug, includes(msg)
-        with_config :cap_key => 5 do
-          5.times { |i| @aggregator.append i}
-        end
-      end
-      def test_notifies_full_resets_after_buffer_reset
-        msg = "TestAggregator capacity of 5 reached"
-        expects_logging :debug, includes(msg)
-        with_config :cap_key => 5 do
-          5.times { |i| @aggregator.append i}
-        end
-        @aggregator.reset!
-        expects_logging :debug, includes(msg)
-        with_config :cap_key => 5 do
-          5.times { |i| @aggregator.append i}
-        end
-      end
-      def test_buffer_class_defaults_to_sampled_buffer
-        assert_kind_of NewRelic::Agent::SampledBuffer, @aggregator.buffer
-      end
-      def test_buffer_class_is_overridable
-        klass = Class.new(EventAggregator) do
-          named :TestAggregator2
-          capacity_key :cap_key
-          enabled_key :enabled_key
-          buffer_class NewRelic::Agent::SizedBuffer
-          attr_reader :buffer
-        end
-        instance = klass.new
-        assert_kind_of NewRelic::Agent::SizedBuffer, instance.buffer
-      end
-      def test_buffer_adjusts_count_by_default_on_merge
-        with_config :cap_key => 5 do
-          buffer = @aggregator.buffer
-          4.times { |i| @aggregator.append i  }
-          last_harvest = @aggregator.harvest!
-          assert_equal 4, buffer.seen_lifetime
-          assert_equal 4, buffer.captured_lifetime
-          assert_equal 4, last_harvest[0][:events_seen]
-          4.times { |i| @aggregator.append i }
-          @aggregator.merge! last_harvest
-          reservoir_stats, samples = @aggregator.harvest!
-          assert_equal 5, samples.size
-          assert_equal 8, reservoir_stats[:events_seen]
-          assert_equal 8, buffer.seen_lifetime
-          assert_equal 5, buffer.captured_lifetime
-        end
-      end
-      def test_buffer_adds_to_original_count_on_merge_when_specified
-        with_config :cap_key => 5 do
-          buffer = @aggregator.buffer
-          4.times { |i| @aggregator.append i  }
-          last_harvest = @aggregator.harvest!
-          assert_equal 4, buffer.seen_lifetime
-          assert_equal 4, buffer.captured_lifetime
-          assert_equal 4, last_harvest[0][:events_seen]
-          4.times { |i| @aggregator.append i }
-          @aggregator.merge! last_harvest, false
-          reservoir_stats, samples = @aggregator.harvest!
-          assert_equal 5, samples.size
-          assert_equal 8, reservoir_stats[:events_seen]
-          assert_equal 12, buffer.seen_lifetime
-          assert_equal 9, buffer.captured_lifetime
-        end
-      end
-    end
-  end
-end

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

@@ -1,168 +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/event_buffer'
-module NewRelic::Agent::EventBufferTestCases
-  # NOTE: Classes including this module must define `buffer_class`; for example:
-  #
-  # def buffer_class
-  #   MyVerySpecialBuffer
-  # end
-  def test_limits_itself_to_capacity
-    buffer = buffer_class.new(10)
-    11.times { |i| buffer.append(i) }
-    assert_equal(10, buffer.size       )
-    assert_equal(11, buffer.num_seen   )
-    assert_equal( 1, buffer.num_dropped)
-  end
-  def test_should_not_discard_items_if_not_needed_when_capacity_is_reset
-    buffer = buffer_class.new(10)
-    assert_equal(10, buffer.capacity)
-    10.times { |i| buffer << i }
-    buffer.capacity = 20
-    assert_equal(10, buffer.size       )
-    assert_equal(20, buffer.capacity   )
-    assert_equal(10, buffer.num_seen   )
-    assert_equal( 0, buffer.num_dropped)
-    assert_equal((0..9).to_a, buffer.to_a)
-  end
-  def test_reset_should_reset
-    buffer = buffer_class.new(10)
-    100.times { |i| buffer << i }
-    buffer.reset!
-    assert_equal(0, buffer.size)
-    assert_equal([], buffer.to_a)
-  end
-  def test_to_a_returns_copy_of_items_array
-    buffer = buffer_class.new(5)
-    5.times { |i| buffer.append(i) }
-    items = buffer.to_a
-    items << ['blarg']
-    assert_equal([0,1,2,3,4], buffer.to_a)
-  end
-  def test_reset_resets_stored_items
-    buffer = buffer_class.new(5)
-    5.times { |i| buffer.append(i) }
-    buffer.reset!
-    assert_equal([], buffer.to_a)
-  end
-  def test_buffer_full_works_properly
-    buffer = buffer_class.new(5)
-    4.times do |i|
-      buffer << i
-      assert_equal(false, buffer.full?, "#{buffer_class}#append should return false until buffer is full")
-    end
-    4.times do |i|
-      buffer << 'lava'
-      assert_equal(true, buffer.full?, "#{buffer_class}#append should return true once buffer is full")
-    end
-  end
-  def test_should_keep_all_samples_up_to_capacity
-    buffer = buffer_class.new(100)
-    all = []
-    100.times do |i|
-      buffer << i
-      all << i
-    end
-    assert_equal(100, buffer.size)
-    assert_equal(all, buffer.to_a)
-  end
-  def test_should_discard_items_as_needed_when_capacity_is_reset
-    buffer = buffer_class.new(10)
-    10.times { |i| buffer << i }
-    buffer.capacity = 5
-    assert_equal(5, buffer.size)
-    # We should have 5 unique values that were all in our original set of 0-9
-    assert_equal(5, buffer.to_a.uniq.size)
-    allowed_values = (0..9).to_a
-    buffer.to_a.each do |v|
-      assert_includes(allowed_values, v)
-    end
-    assert_equal(10, buffer.num_seen   )
-    assert_equal( 5, buffer.num_dropped)
-  end
-  def test_num_seen_counts_all_seen_samples_since_last_reset
-    buffer = buffer_class.new(10)
-    assert_equal(0, buffer.num_seen)
-    20.times { |i| buffer << i }
-    assert_equal(20, buffer.num_seen)
-    buffer.reset!
-    assert_equal(0, buffer.num_seen)
-  end
-  def test_append_increments_drop_count_when_over_capacity
-    buffer = buffer_class.new(5)
-    5.times { |i| buffer.append(i) }
-    assert_equal(0, buffer.num_dropped)
-    5.times { |i| buffer.append(i) }
-    assert_equal(5, buffer.num_dropped)
-  end
-  def test_reset_resets_drop_count
-    buffer = buffer_class.new(5)
-    10.times { |i| buffer.append(i) }
-    assert_equal(5, buffer.num_dropped)
-    buffer.reset!
-    assert_equal(0, buffer.num_dropped)
-  end
-  def test_sample_rate
-    buffer = buffer_class.new(10)
-    assert_equal(0, buffer.sample_rate)
-    10.times { buffer << 'x' }
-    assert_equal(1.0, buffer.sample_rate)
-    10.times { buffer << 'x' }
-    assert_equal(0.5, buffer.sample_rate)
-  end
-  def test_metadata
-    buffer = buffer_class.new(5)
-    7.times { buffer << 'x' }
-    expected = {
-      :capacity => 5,
-      :seen => 7,
-      :captured => 5
-    }
-    metadata = buffer.metadata
-    metadata.delete :captured_lifetime
-    metadata.delete :seen_lifetime
-    assert_equal expected, metadata
-  end
-end

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

@@ -1,70 +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 EventListenerTest < Minitest::Test
-  def setup
-    @events = NewRelic::Agent::EventListener.new
-    @called = false
-    @called_with = nil
-    @check_method = Proc.new do |*args|
-      @called = true
-      @called_with = args
-    end
-  end
-  #
-  # Helpers
-  #
-  def assert_was_called
-    assert @called, "Event wasn't called"
-  end
-  def assert_was_not_called
-    assert !@called, "Event was called"
-  end
-  #
-  # Tests
-  #
-  def test_notifies
-    @events.subscribe(:before_call, &@check_method)
-    @events.notify(:before_call, :env => "env")
-    assert_was_called
-    assert_equal([{:env => "env"}], @called_with)
-  end
-  def test_failure_during_notify_doesnt_block_other_hooks
-    @events.subscribe(:after_call) { raise "Boo!" }
-    @events.subscribe(:after_call, &@check_method)
-    @events.notify(:after_call)
-    assert_was_called
-  end
-  def test_runaway_events
-    @events.runaway_threshold = 0
-    expects_logging(:debug, includes("my_event"))
-    @events.subscribe(:my_event) {}
-  end
-  def test_clear
-    @events.subscribe(:after_call, &@check_method)
-    @events.clear
-    @events.notify(:after_call)
-    assert_was_not_called
-  end
-end

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

@@ -1,202 +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 NewRelic::Agent::EventLoopTest < Minitest::Test
-  def setup
-    freeze_time
-    @loop = NewRelic::Agent::EventLoop.new
-  end
-  def test_fire_after
-    call_count = 0
-    @loop.on(:event) { call_count += 1 }
-    @loop.fire_after(3, :event)
-    @loop.run_once(true)
-    assert_equal(0, call_count)
-    advance_loop(1)
-    assert_equal(0, call_count)
-    advance_loop(2)
-    assert_equal(1, call_count)
-    advance_loop(5)
-    assert_equal(1, call_count)
-  end
-  def test_fire_every
-    call_count = 0
-    @loop.on(:event) do
-      call_count += 1
-    end
-    @loop.fire_every(3, :event)
-    @loop.run_once(true)
-    assert_equal(0, call_count)
-    advance_loop(2)
-    assert_equal(0, call_count)
-    advance_loop(1)
-    assert_equal(1, call_count)
-    advance_loop(4)
-    assert_equal(2, call_count)
-  end
-  def test_fire_resets_associated_timers
-    call_count = 0
-    @loop.on(:event) { call_count += 1 }
-    @loop.fire_every(10, :event)
-    advance_loop(5)
-    @loop.fire(:event)
-    @loop.run_once(true)
-    assert_equal(1, call_count)
-    advance_loop(5)
-    assert_equal(1, call_count)
-    advance_loop(5)
-    assert_equal(2, call_count)
-  end
-  def test_adjust_period_larger
-    call_count = 0
-    @loop.on(:e) { call_count += 1 }
-    @loop.fire_every(10, :e)
-    @loop.run_once(true)
-    advance_loop(9)
-    assert_equal(0, call_count)
-    @loop.fire_every(15, :e)
-    @loop.run_once(true)
-    assert_equal(0, call_count)
-    advance_loop(1)
-    assert_equal(0, call_count)
-    advance_loop(5)
-    assert_equal(1, call_count)
-  end
-  def test_adjust_period_smaller
-    call_count = 0
-    @loop.on(:e) { call_count += 1 }
-    @loop.fire_every(10, :e)
-    @loop.run_once(true)
-    assert_equal(0, call_count)
-    advance_loop(5)
-    assert_equal(0, call_count)
-    @loop.fire_every(2, :e)
-    @loop.run_once(true)
-    assert_equal(1, call_count)
-    advance_loop(1)
-    assert_equal(1, call_count)
-    advance_loop(1)
-    assert_equal(2, call_count)
-  end
-  def test_on
-    call_count = 0
-    @loop.on(:evt) do
-      call_count += 1
-    end
-    @loop.fire(:evt)
-    @loop.run_once(true)
-    assert_equal(1, call_count)
-  end
-  def test_on_with_payload
-    call_count = 0
-    @loop.on(:evt) do |amount|
-      call_count += amount
-    end
-    @loop.fire(:evt, 42)
-    @loop.run_once(true)
-    assert_equal(42, call_count)
-  end
-  def test_manual_fire_resets_timers
-    call_count = 0
-    @loop.on(:e) { call_count += 1 }
-    @loop.fire_every(4, :e)
-    advance_loop(3)
-    assert_equal(0, call_count)
-    @loop.fire(:e)
-    @loop.run_once(true)
-    assert_equal(1, call_count)
-    advance_loop(3)
-    assert_equal(1, call_count)
-    advance_loop(1)
-    assert_equal(2, call_count)
-  end
-  def test_exceptions_do_not_exit_loop
-    call_count = 0
-    @loop.on(:e) { raise StandardError.new }
-    @loop.on(:e) { call_count += 1 }
-    @loop.on(:e) { raise StandardError.new }
-    @loop.fire(:e)
-    @loop.run_once(true)
-    assert_equal(1, call_count)
-  end
-  def test_timer_period_reset_from_event
-    call_count = 0
-    @loop.on(:e           ) { call_count += 1          }
-    @loop.on(:reset_period) { @loop.fire_every(30, :e) }
-    @loop.fire_every( 5, :e           )
-    @loop.fire_after(31, :reset_period)
-    advance_loop(3)  # total time 3
-    assert_equal(0, call_count)
-    advance_loop(2)  # total time 5
-    assert_equal(1, call_count)
-    advance_loop(5)  # total time 10
-    assert_equal(2, call_count)
-    advance_loop(20)  # total time 30
-    assert_equal(6, call_count)
-    advance_loop(29)  # total time 59
-    assert_equal(6, call_count)
-    advance_loop(1)  # total time 60
-    assert_equal(7, call_count)
-    advance_loop(60)  # total time 120
-    assert_equal(9, call_count)
-  end
-  def advance_loop(n)
-    n.times do
-      advance_time(1)
-      @loop.run_once(true)
-    end
-  end
-end