active_metric 2.5.2

data/test/reservoir_test.rb

@@ -0,0 +1,67 @@
+require_relative "test_helper"
+
+module ActiveMetric
+  class ReservoirTest < ActiveSupport::TestCase
+
+    class Measurement
+      attr_accessor :value
+    end
+
+    setup do
+      @reservoir = Reservoir.new(10)
+    end
+
+    test "can initialize reservoir with type and size" do
+      assert_equal @reservoir.size,   10
+    end
+
+    test "can fill reservoir" do
+      @reservoir.fill create_measurement(1)
+    end
+
+    test "can fill reservoir and calculate percentile" do
+      (1..10).reverse_each do |value|
+        @reservoir.fill create_measurement(value)
+      end
+      assert_equal 9, @reservoir.calculate_percentile(0.8, :value)
+      assert_equal 10, @reservoir.calculate_percentile(0.98, :value)
+    end
+
+    test "calculates based on moving window" do
+      (1..20).reverse_each do |value|
+        @reservoir.fill create_measurement(value)
+      end
+
+      assert_equal 9, @reservoir.calculate_percentile(0.8, :value)
+      assert_equal 10, @reservoir.calculate_percentile(0.98, :value)
+    end
+    
+    test "can calculate standard deviation for window" do
+      reverse_fill(1..20)
+      assert_close_to 2.87, @reservoir.calculate_standard_deviation(:value)
+      reverse_fill(95..100)
+      assert_close_to 46.56, @reservoir.calculate_standard_deviation(:value)
+      reverse_fill(90..95)
+      assert_close_to 2.47, @reservoir.calculate_standard_deviation(:value)
+    end
+
+    private
+    
+    def reverse_fill(range)
+      range.reverse_each do |value|
+        @reservoir.fill create_measurement(value)
+      end
+    end
+
+    def shuffle(array)
+      array.size.downto(1) { |n| array.push array.delete_at(rand(n)) }
+    end
+
+    def create_measurement(value)
+      measurement = Measurement.new
+      measurement.value = value
+      measurement
+    end
+
+  end
+end

data/test/sample_test.rb

@@ -0,0 +1,142 @@
+require_relative "test_helper"
+
+module ActiveMetric
+  class SampleTest < ActiveSupport::TestCase
+
+    test "should have the correct stats by name" do
+      subject = TestSubject.new
+      sample = TestSample.new(:samplable => subject)
+      assert_equal 12, sample.stats.size
+      assert_kind_of Min, sample.min_value
+      assert_kind_of Mean, sample.mean_value
+      assert_kind_of Max, sample.max_value
+      assert_kind_of Eightieth, sample.eightieth_value
+      assert_kind_of NinetyEighth, sample.ninety_eighth_value
+      assert_kind_of StandardDeviation, sample.standard_deviation_value
+      assert_kind_of Delta, sample.delta_value
+      assert_kind_of Bucket, sample.bucket_value
+      assert_kind_of Speed, sample.speed_value
+      assert_kind_of PercentFalse, sample.percent_false_value
+      assert_kind_of TestCount, sample.test_count
+      assert_kind_of TestResponseCodes, sample.test_response_codes
+    end
+
+    test "samples spawned from samples contain seed measurement" do
+      subject = TestSubject.new
+
+      num_measurements = 5
+
+      sample = TestSample.new(:interval => 6, :samplable => subject)
+
+      num_measurements.times do |time|
+        sample.calculate TestMeasurement.new :value => 1, :timestamp => time
+      end
+
+      new_sample = sample.new_sample
+
+      assert_not_equal sample, new_sample
+      assert_equal 4, new_sample.seed_measurement.timestamp
+      assert_equal sample.latest_measurement, new_sample.seed_measurement
+    end
+
+
+    test "should have correct timestamp" do
+      measurements = [TestMeasurement.new(:value => 10, :timestamp => 1),
+                      TestMeasurement.new(:value => 12, :timestamp => 2),
+                      TestMeasurement.new(:value => 11, :timestamp => 9)]
+
+      subject = TestSubject.create
+      sample = TestSample.new(:samplable => subject)
+      measurements.each do |measurement|
+        sample.calculate(measurement)
+      end
+      assert_equal (4), sample.timestamp
+    end
+
+    test "should call calculate on all stats" do
+      subject = TestSubject.create
+      sample = TestSample.new(:samplable => subject)
+      5.times do |value|
+        measurement = TestMeasurement.new :value => value, :timestamp => 1
+        sample.stats.each do |stat|
+          stat.expects(:calculate).with(measurement)
+        end
+        sample.calculate measurement
+      end
+
+      sample.stats.each do |stat|
+        stat.expects(:complete)
+      end
+      sample.complete
+    end
+
+    test "should return raw stat if sample does not have that stat" do
+      sample = TestSample.new
+      stat = sample.this_stat_does_not_exist
+      assert_equal 0, stat.value
+    end
+
+    test "should return stat if sample has it" do
+      sample = TestSample.new
+      stat = sample.min_value
+      assert stat.kind_of? Min
+    end
+
+    test "is summary" do
+      subject = TestSubject.create
+      summary = subject.summary
+      assert summary.is_summary?
+    end
+
+    test "summary only should set start time after first measurement" do
+      subject = TestSubject.create
+      summary = subject.summary
+      assert_nil summary.start_time
+
+
+      summary.calculate(TestMeasurement.new :value => 1, :timestamp => 1)
+      assert_equal 1, summary.start_time
+    end
+
+    test "duration from previous sample defaults to current sample duration if no previous sample" do
+      nil_seed_measurement = nil
+      sample = TestSample.new({},nil_seed_measurement)
+      sample.expects(:duration_in_seconds)
+      sample.duration_from_previous_sample_in_seconds
+    end
+
+    test "duration from previous sample returns correct duration" do
+      seed_measurement = mock
+
+      seed_measurement.expects(:timestamp).returns(100)
+
+      sample = TestSample.new({},{}, seed_measurement)
+      sample.expects(:end_time).returns(200)
+
+      assert_equal 100, sample.duration_from_previous_sample_in_seconds
+    end
+
+    test "passing in just a hash to create sets seed measurement to nil" do
+      subject = TestSubject.new
+
+      sample = TestSample.create( {:samplable => subject, :foo => "bar"} )
+      assert_nil sample.seed_measurement
+
+    end
+
+    test "stat definitions have proper axis" do
+      @stat_definitions = TestSample.stats_defined
+      assert_contains_axis(:min_value,0)
+      assert_contains_axis(:mean_value,0)
+      assert_contains_axis(:max_value,0)
+      assert_contains_axis(:standard_deviation_value,1)
+      assert_contains_axis(:test_count,1)
+      assert_contains_axis(:test_response_codes, -1)
+    end
+
+    def assert_contains_axis(stat,axis)
+      assert_equal axis, @stat_definitions.select {|sd| sd.access_name == stat}.first.options[:axis]
+    end
+
+  end
+end

data/test/series_data_test.rb

@@ -0,0 +1,20 @@
+require_relative "test_helper"
+
+module ActiveMetric
+  class SeriesDataTest < ActiveSupport::TestCase
+
+    test "can instantiate from stat definition" do
+      access_name = "name_of_stat"
+      options = {axis: 2, visible: false}
+      stat_definition = StatDefinition.new(:property,Min,access_name,options)
+      series = SeriesData.from_stat_definition(stat_definition)
+
+      assert_equal access_name, series.label
+      assert_equal 2, series.y_axis
+      assert_equal 0, series.x_axis
+      assert_equal false, series.visible
+    end
+
+
+  end
+end

data/test/standard_deviator_test.rb

@@ -0,0 +1,45 @@
+require_relative "test_helper"
+module ActiveMetric
+  class StandardDeviatorTest < ActiveSupport::TestCase
+
+    test "can calculate standard deviation" do
+      sd = StandardDeviator.new(:value)
+      test_stat(sd, 100.times)
+      assert_close_to 28.87, sd.standard_deviation
+    end
+
+    test "memoize standard deviation with a single measurement" do
+      sd = StandardDeviator.new(:value)
+      sd.expects(:calculate_standard_deviation).returns(5)
+      test_stat(sd, 1.times)
+      assert_equal 5, sd.standard_deviation
+      assert_equal 5, sd.standard_deviation
+    end
+
+    test "un-memoizes standard deviation with new measurement" do
+      sd = StandardDeviator.new(:value)
+      sd.expects(:calculate_standard_deviation).twice.returns(5,2)
+      test_stat(sd, 1.times)
+      assert_equal 5, sd.standard_deviation
+      assert_equal 5, sd.standard_deviation
+      test_stat(sd, 1.times)
+      assert_equal 2, sd.standard_deviation
+    end
+
+    test "can calculate standard deviation with no calculations " do
+      sd = StandardDeviator.new(:value)
+      assert_equal 0, sd.standard_deviation
+    end
+
+    private
+
+    def test_stat(stat, values)
+      values.each do |value|
+        stat.calculate TestMeasurement.new(:value => value)
+      end
+    end
+
+
+  end
+
+end

data/test/stat_test.rb

@@ -0,0 +1,222 @@
+require_relative 'test_helper'
+
+module ActiveMetric
+  class StatTest < ActiveSupport::TestCase
+
+    setup do
+      @subject = TestSubject.create
+      @sample = TestSample.create({:samplable => @subject})
+      @stat = TestStat.new :property, :calculable => @sample
+    end
+
+    test "create a new stat" do
+      assert @stat
+    end
+
+    test "stat is a mongoid document" do
+      assert @stat.kind_of?(Mongoid::Document)
+    end
+
+    test "calculate raises an error if not implemented" do
+      assert_raise CannotInstantiateBaseStat do
+        @stat.calculate(mock)
+      end
+    end
+
+    test "has a dynamically defined name" do
+      assert_equal :test_stat_property, @stat.access_name
+    end
+
+    test "sets name for custom stat" do
+      proc = Proc.new { |m| self.value = m.value }
+      stat = Stat.create_custom_stat(:property, Integer, {}, proc).new(:property)
+      assert_equal :property, stat.access_name
+    end
+
+    test "custom stat uses block to calculate" do
+      proc = Proc.new { |m| self.value = m.value }
+      stat = Stat.create_custom_stat(:property, Integer, {}, proc).new(:property)
+      measurement = mock(:value => 10)
+      stat.calculate(measurement)
+      assert_equal 10, stat.value
+    end
+
+    test "can calculate min" do
+      stat = Min.new(:value, :calculable => @sample)
+      test_stat(stat, 10.times)
+      assert_equal 0, stat.value
+    end
+
+    test "can calculate max" do
+      stat = Max.new(:value, :calculable => @sample)
+      test_stat(stat, 10.times)
+      assert_equal 9, stat.value
+    end
+
+    test "can calculate mean" do
+      stat = Mean.new(:value, :calculable => @sample)
+      test_stat(stat, 10.times)
+      assert_equal 4.5, stat.value
+    end
+
+    test "can calculate derivative without seed_measurement" do
+      stat = Derivative.new(:value, :calculable => @sample)
+      @sample.stubs(:seed_measurement).returns(nil)
+
+      @sample.expects(:duration_from_previous_sample_in_seconds).times(2).returns(0, 1)
+      test_stat(stat, [1, 2])
+      slope_of_one = 1.0
+
+      assert_equal slope_of_one, stat.value
+    end
+
+    test "can calculate derivative with seed_measurement " do
+      stat = Derivative.new(:value, :calculable => @sample)
+
+      @sample.stubs(:seed_measurement).returns(test_seed_measurement)
+      @sample.expects(:duration_from_previous_sample_in_seconds).times(2).returns(1, 2)
+      test_stat(stat, [2, 3])
+
+      slope_of_one = 1.0
+
+      assert_equal slope_of_one, stat.value
+    end
+
+    test "can calculate last derivative without seed_measurement" do
+      stat = LastDerivative.new(:value, :calculable => @sample)
+      @sample.stubs(:seed_measurement).returns(nil)
+
+      test_stat(stat, [1])
+      no_derivative = 0
+
+      assert_equal no_derivative, stat.value
+    end
+
+    test "can calculate last derivative with seed measurement" do
+      stat = LastDerivative.new(:value, :calculable => @sample)
+
+      @sample.stubs(:seed_measurement).returns(test_seed_measurement)
+      test_stat(stat, [2, 4], [2, 3])
+
+      slope_of_two = 2.0
+
+      assert_equal slope_of_two, stat.value
+    end
+
+    test "can calculate speed" do
+      stat = Speed.new(:value, :calculable => @sample)
+
+      @sample.stubs(:seed_measurement).returns(test_seed_measurement)
+      @sample.expects(:duration_from_previous_sample_in_seconds).times(4).returns(1, 2, 3, 4)
+
+      test_stat(stat, [2, 3, 4, 5])
+
+      speed_of_one_per_second = 1.0
+      assert_equal speed_of_one_per_second, stat.value
+
+    end
+
+    test "can calculate delta without seed measurement" do
+      stat = Delta.new(:value, :calculable => @sample)
+      @sample.stubs(:seed_measurement).returns(nil)
+
+      test_stat(stat, [1, 5, 10])
+      assert_equal 9, stat.value
+    end
+
+    test "can calculate delta with seed measurement" do
+      stat = Delta.new(:value, :calculable => @sample)
+      @sample.stubs(:seed_measurement).returns(test_seed_measurement)
+
+      test_stat(stat, [5, 10])
+      assert_equal 9, stat.value
+    end
+
+    test "can calculate sum" do
+      stat = Sum.new(:value, :calculable => @sample)
+      test_stat(stat, 10.times)
+      assert_equal 45, stat.value
+    end
+
+    test "can calculate last" do
+      stat = Last.new(:value, :calculable => @sample)
+      test_stat(stat, 10.times)
+      assert_equal 9, stat.value
+    end
+
+    test "can calculate count" do
+      stat = Count.new(:value, :calculable => @sample)
+      test_stat(stat, 10.times)
+      assert_equal 10, stat.value
+    end
+
+    test "can calculate true count" do
+      stat = TrueCount.new(:value, :calculabe => @sample)
+      values = [true, true, false]
+      test_stat(stat, values)
+      assert_equal 2, stat.value
+    end
+
+    test "can calculate false count" do
+      stat = FalseCount.new(:value, :calculabe => @sample)
+      values = [true, true, false]
+      test_stat(stat, values)
+      assert_equal 1, stat.value
+    end
+
+    test "can bucket values" do
+      stat = Bucket.new(:value, :calculabe => @sample)
+      values = [200, 404, 500, 502, 200, 500, 504.2]
+      test_stat(stat, values)
+      expected_bucket = {
+          "200" => 2,
+          "404" => 1,
+          "500" => 2,
+          "502" => 1,
+          "504_2" => 1
+      }
+      assert_equal expected_bucket, stat.value
+    end
+
+    test "can calculate false percentage" do
+      stat = PercentFalse.new(:value, :calculabe => @sample)
+      values = [true, true, false, true]
+      test_stat(stat, values)
+      assert_equal 25, stat.value
+    end
+
+
+    #this test is here for the user, not for automated tests
+    #test "random distributions are good too" do
+    #  stat = StandardDeviation.new(:value, :calculable => @sample)
+    #  100.times do
+    #    stat.calculate TestMeasurement.create(:value => rand(100))
+    #  end
+    #  stat.complete
+    #  assert_close_to 28.87, stat.value
+    #end
+
+    test "has subject" do
+      subject = TestSubject.create
+      sample = TestSample.create(:samplable => subject)
+      assert_equal subject, sample.stats.first.subject
+    end
+
+    private
+
+    def test_stat(stat, values, timestamps = values.to_a)
+      values.each_with_index do |value, index|
+        stat.calculate TestMeasurement.new(:value => value, :timestamp => timestamps[index])
+      end
+      stat.complete
+    end
+
+    def test_seed_measurement
+      seed_measurement = mock()
+      seed_measurement.stubs(:value).returns(1)
+      seed_measurement.stubs(:timestamp).returns(1)
+      seed_measurement
+    end
+
+  end
+end