active_metric 2.5.2

data/test/graph_view_model_test.rb

@@ -0,0 +1,92 @@
+require_relative "test_helper"
+
+module ActiveMetric
+  class GraphViewModelTest < ActiveSupport::TestCase
+
+    EULERS_DAY= MONGO_MAX_LIMIT = (1 << 31) - 1
+
+    test "can retrieve series by label" do
+      gvm = GraphViewModel.create
+      gvm.series_data << generate_series_data(5, "first")
+      gvm.series_data << generate_series_data(5, "second")
+
+      series = gvm.series_for("second")
+
+      assert_equal "second", series.label
+
+    end
+
+    test "size returns 0 if no series_data" do
+      gvm = GraphViewModel.create
+      assert_equal 0, gvm.size
+    end
+
+    test "can create from definitions" do
+      axises_defintions = [{index: 1, label: "second"},
+                           {index: 0, label: "first"},
+                           {index: 0, label: "actually first"}]
+      options = {name: "test graph"}
+
+      stat_definitions  = []
+      stat_definitions << stat_definition(true)
+      stat_definitions << stat_definition(true)
+      stat_definitions << stat_definition(false)
+
+      gvm = GraphViewModel.create_from_meta_data(axises_defintions, stat_definitions, options)
+
+      assert_equal 2, gvm.y_axises.size
+
+      index_zero_axises = gvm.y_axises.select{|axis| axis.index == 0}
+
+      assert_equal 1, index_zero_axises.size
+      assert_equal 0, index_zero_axises.first.index
+      assert_equal "actually first", index_zero_axises.first.label
+
+      assert_equal 2, gvm.series_data.size
+    end
+
+    test "can read y_axises sorted by index" do
+      axises_defintions = [{index: 1, label: "second"},
+                           {index: 0, label: "first"},
+                           {index: 0, label: "actually first"}]
+
+      gvm = GraphViewModel.create_from_meta_data(axises_defintions, [], {})
+
+      axises = gvm.ordered_y_axises
+
+      assert_equal 2, axises.size
+
+      assert_equal 0, axises.first.index
+      assert_equal "actually first", axises.first.label
+
+      assert_equal 1, axises.second.index
+      assert_equal "second", axises.second.label
+    end
+
+
+    test "can retrieve partial array" do
+      subject = Subject.create
+      graph_view_model = subject.graph_view_model
+      graph_view_model.series_data << generate_series_data(4)
+      graph_view_model.series_data << generate_series_data(4,"label 2")
+
+      partial_graph = subject.graph_view_model_starting_at(2)
+
+      assert_equal [[2,2],[3,3]], partial_graph.series_data.first.data
+      assert_equal [[2,2],[3,3]], partial_graph.series_data.second.data
+
+    end
+
+    def generate_series_data(x_count, label = "label")
+      data = []
+      x_count.times {|x| data << [x,x]}
+      PointSeriesData.new(data: data, label: label)
+    end
+
+    def stat_definition(graphable)
+      axis = graphable ? 0 : -1
+      StatDefinition.new(:name_of_stat,Min,"min_name_of_stat",{axis: axis})
+    end
+
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,149 @@
+require_relative 'test_helper'
+
+module ActiveMetric
+
+  class IntegrationTest < ActiveSupport::TestCase
+
+    test "can calculate correct eightieth percentile for subject" do
+      report = Report.create
+      subject = TestSubject.create :report => report
+      subject2 = TestSubject.create :report => report
+      10.times do |value|
+        subject.calculate TestMeasurement.new(:value => 100 - value, :timestamp => value)
+      end
+      10.times do |value|
+        subject2.calculate TestMeasurement.new(:value => 200 - value, :timestamp => value)
+      end
+      subject2.complete
+      subject.complete
+      assert_equal 99, subject.summary.eightieth_value.value
+      assert_equal 199, subject2.summary.eightieth_value.value
+    end
+
+    test "can calculate correct ninety eighth percentile for subject" do
+      report = Report.create
+      subject = TestSubject.create :report => report
+      subject2 = TestSubject.create :report => report
+      5.times do |value|
+        subject.calculate TestMeasurement.new(:value => 100 - value, :timestamp => value)
+      end
+      5.times do |value|
+        subject.calculate TestMeasurement.new(:value => 150 - value, :timestamp => value)
+      end
+      10.times do |value|
+        subject2.calculate TestMeasurement.new(:value => 200 - value, :timestamp => value)
+      end
+      subject2.complete
+      subject.complete
+      assert_equal 150, subject.summary.ninety_eighth_value.value
+      assert_equal 200, subject2.summary.ninety_eighth_value.value
+    end
+
+    test "can calculate correct percentiles with multiple subjects" do
+      report = Report.create
+      subject = TestSubject.create :report => report
+      subject2 = TestSubject.create :report => report
+      5.times do |value|
+        subject.calculate TestMeasurement.new(:value => 100 - value, :timestamp => value)
+      end
+      5.times do |value|
+        subject.calculate TestMeasurement.new(:value => 150 - value, :timestamp => value)
+      end
+      10.times do |value|
+        subject2.calculate TestMeasurement.new(:value => 155 - value, :timestamp => value)
+      end
+      subject2.complete
+      subject.complete
+
+      assert_equal 149, subject.summary.eightieth_value.value
+      assert_equal 150, subject.summary.ninety_eighth_value.value
+
+      assert_equal 154, subject2.summary.eightieth_value.value
+      assert_equal 155, subject2.summary.ninety_eighth_value.value
+    end
+
+    test "can calculate standard deviations" do
+      report = Report.create
+      subject = TestSubject.create :report => report
+      10.times do |value|
+        subject.calculate TestMeasurement.new(:value => 100 - value, :timestamp => value)
+      end
+
+      subject.complete
+      assert_close_to 2.87, subject.summary.standard_deviation_value.value
+    end
+
+    test "summary should update when samples changes" do
+      report = Report.create
+      subject = TestSubject.create :report => report
+      6.times do |value|
+        subject.calculate TestMeasurement.new(:value => value, :timestamp => value)
+      end
+
+      assert_equal 4.0, subject.summary.eightieth_value.value
+
+      subject.calculate TestMeasurement.new(:value => 6, :timestamp => 6)
+
+      assert_equal 4.0, subject.summary.eightieth_value.value
+    end
+
+    test "subjects should delegate to summaries" do
+      report = Report.create
+      subject = TestSubject.create :report => report
+      6.times do |value|
+        subject.calculate TestMeasurement.new(:value => value, :timestamp => value)
+      end
+
+      assert_equal 4.0, subject.eightieth_value
+      assert_equal 4.0, subject.eightieth_value
+    end
+
+    test "subjects should delegate to document before summaries" do
+      report = Report.create
+      subject = TestSubject.create :report => report, :test_field => "subject name"
+      6.times do |value|
+        subject.calculate TestMeasurement.new(:value => value, :timestamp => value)
+      end
+      assert_equal "subject name", subject.test_field
+      assert_equal 4.0, subject.eightieth_value
+    end
+
+    test "subjects should be able to delegate to non stat properties on summary" do
+      report = Report.create
+      subject = TestSubject.create :report => report
+      6.times do |value|
+        subject.calculate TestMeasurement.new(:value => value, :timestamp => value)
+      end
+      assert_equal 5, subject.duration_in_seconds
+      assert_equal 5, subject.duration_in_seconds
+    end
+
+    test "no measurements or interval samples should be in the database" do
+      report = Report.create
+      subject = TestSubject.create :report => report
+      subject2 = TestSubject.create :report => report
+      11.times do |value|
+        subject.calculate TestMeasurement.new(:value => 100 - value, :timestamp => value)
+      end
+      10.times do |value|
+        subject2.calculate TestMeasurement.new(:value => 200 - value, :timestamp => value)
+      end
+      subject2.complete
+      subject.complete
+      assert_equal 90, subject.min_value
+      assert_equal 191, subject2.min_value
+
+      assert_equal 0, ActiveMetric::Measurement.count
+      assert_equal 0, ActiveMetric::Sample.where(:interval.ne => nil).count
+      assert_equal 2, ActiveMetric::Sample.where(:interval => nil).count
+    end
+
+    private
+
+    def assert_within_threshold(threshold, actual, estimated)
+      range_val = actual * threshold
+      range = ((actual - range_val)..(actual + range_val))
+      assert_within_range range, estimated
+    end
+  end
+end

data/test/measurement_test.rb

@@ -0,0 +1,45 @@
+require_relative 'test_helper'
+
+module ActiveMetric
+
+  class MeasurementTest < ActiveSupport::TestCase
+
+    setup do
+      @measurement = TestMeasurement.new
+    end
+
+    test 'can create measurement' do
+      assert @measurement
+    end
+
+    test 'is a mongoid document' do
+      assert @measurement.kind_of? Mongoid::Document
+    end
+
+    test 'time returns datetime in seconds for timestamp' do
+      @measurement.timestamp = 1318338826385
+      assert_equal Time.at(1318338826), @measurement.time
+    end
+
+    test "converts appropriate fields to integer" do
+      assert_saves_as_integer @measurement, :timestamp
+    end
+
+    test "measurements default timestamp to now" do
+      assert @measurement.timestamp
+      sleep(1)
+      measurement2 = TestMeasurement.new
+      assert measurement2.timestamp
+
+      assert_not_equal @measurement.timestamp, measurement2.timestamp
+    end
+
+    private
+
+    def assert_saves_as_integer(measurement, field)
+      measurement.send("#{field}=","12345")
+      measurement.save!
+      assert_equal 12345, measurement.send(field)
+    end
+  end
+end

data/test/mongoid_test.rb

@@ -0,0 +1,24 @@
+require_relative 'test_helper'
+
+class MongoidTest < ActiveSupport::TestCase
+
+
+  test "inherited documents from class dot new dont get a type" do
+    class TopLevel
+      include Mongoid::Document
+    end
+
+    class SecondLevel < TopLevel
+    end
+
+    second_level = SecondLevel.create
+    assert_equal "MongoidTest::SecondLevel", second_level._type
+
+    klass = Class.new(TopLevel)
+    MongoidTest.const_set(:NewKlass, klass)
+
+    new_object = NewKlass.create
+    assert_equal "MongoidTest::NewKlass", new_object._type
+    #assert_equal nil, new_object._type, "Mongoid correctly sets _type on Anonymous Classes now. Go remove the hack in stat: create_custom_stat WRT _type  "
+  end
+end

data/test/point_series_data_test.rb

@@ -0,0 +1,27 @@
+require_relative "test_helper"
+
+module ActiveMetric
+  class PointSeriesDataTest < ActiveSupport::TestCase
+
+    test "can push and pop atomically" do
+      gvm = GraphViewModel.create
+      psd = PointSeriesData.new(data: [[1,1],[2,2]])
+      gvm.series_data << psd
+
+      psd.pop_data
+
+      assert_equal [[1,1]], psd.data
+
+      psd.push_data([3,3])
+
+      assert_equal [[1,1],[3,3]], psd.data
+    end
+
+    test "can calculate size of data" do
+      psd = PointSeriesData.new(data: [[1,1],[2,2]])
+
+      assert_equal 2, psd.size
+    end
+
+  end
+end

data/test/report_test.rb

@@ -0,0 +1,73 @@
+require_relative 'test_helper'
+
+module ActiveMetric
+
+  class ReportTest < ActiveSupport::TestCase
+
+
+    test "method missing for subjects" do
+      report = Report.create
+      subjects = 2.times.map  {TestSubject.create :report => report}
+      assert_equal subjects, report.test_subjects
+    end
+
+    test "responds properly to method missing if not a subject name" do
+      report = Report.create
+      assert_raises NoMethodError do
+        report.bad_method
+      end
+    end
+
+    test "can still use dynamic fields with overwritten method missing" do
+      report = Report.create :some_random_field => "value"
+      assert_equal "value", report.some_random_field
+    end
+
+    test "can still access dynamic fields with subjects in name" do
+      report = Report.create :some_subjects => "value"
+      assert_equal "value", report.some_subjects
+    end
+
+    test "can delete a report" do
+      report = Report.create
+      report.subjects.create
+
+      report.delete
+
+      assert_equal 0, ActiveMetric::Report.count
+      assert_equal 0, ActiveMetric::Subject.count
+      assert_equal 0, ActiveMetric::Sample.count
+      assert_equal 0, ActiveMetric::GraphViewModel.count
+
+    end
+
+    test "can set display name" do
+      class TestReport < Report
+
+        def set_display_name
+          "Overriden Display Name"
+        end
+      end
+
+      report = TestReport.create
+
+      assert_equal "Overriden Display Name", report.display_name
+    end
+
+    test "can set display name through attribute" do
+      class TestReport < Report
+
+        def set_display_name
+          "TestReport Display Name"
+        end
+      end
+
+      report = TestReport.create display_name: "Overriden Display Name"
+
+      assert_equal "Overriden Display Name", report.display_name
+    end
+
+
+
+  end
+end

data/test/report_view_model_test.rb

@@ -0,0 +1,94 @@
+require_relative "test_helper"
+
+module ActiveMetric
+  class ReportViewModelTest < ActiveSupport::TestCase
+
+    class TestReportViewModel < ActiveMetric::ReportViewModel
+
+      table :table1 do
+        column "header 1", :field1
+        column "header 2", :field2, :precision => 2
+        column "header 3", :field3, :format => :duration_with_format
+      end
+
+      table :table2 do
+        column "header 1", :field1
+        column "header 2", :field2
+      end
+
+    end
+
+    test "can instantiate a view model" do
+      rvm = TestReportViewModel.new
+      rvm.add_table :table1, subjects
+      table = rvm.tables.first
+
+      expected_headers = ["header 1", "header 2", "header 3"]
+      assert_equal expected_headers, table.headers
+
+      expected_cells = ["name",2.8345, 3]
+      expected_cell_options = [{},{:precision =>2},{:format => :duration_with_format}]
+      table.rows.each do |row|
+        assert_equal expected_cells, row.cells.map(&:value)
+        assert_equal expected_cell_options, row.cells.map(&:format_options)
+        assert row.has_series
+      end
+    end
+
+    test "cannot add a table that does not exist" do
+      rvm = TestReportViewModel.new
+      assert_raise ReportViewModel::TableDoesNotExist do
+        rvm.add_table :bad_table, subjects
+      end
+    end
+
+    test "can have multiple tables" do
+      rvm = TestReportViewModel.new
+      rvm.add_table :table1, subjects
+      rvm.add_table :table2, subjects
+      rvm.add_table :table1, subjects
+
+      table1_headers  = ["header 1", "header 2", "header 3"]
+      table2_headers = ["header 1", "header 2"]
+
+      assert_equal table1_headers, rvm.tables[0].headers
+      assert_equal table2_headers, rvm.tables[1].headers
+      assert_equal table1_headers, rvm.tables[2].headers
+
+      table1_data = ["name",2.8345, 3]
+      table2_data = ["name",2.8345]
+      table3_data = ["name",2.8345, 3]
+
+      assert_table_data table1_data, rvm.tables[0]
+      assert_table_data table2_data, rvm.tables[1]
+      assert_table_data table3_data, rvm.tables[2]
+    end
+
+
+    def assert_table_data(data, table)
+      table.rows.each do |row|
+        assert_equal data, row.cells.map(&:value)
+        assert_equal "1", row.row_id
+      end
+    end
+
+    def subjects
+      subject = create_row_data(field1: "name",
+                                field2: 2.8345,
+                                field3: 3)
+
+      subject.stubs(:to_param).returns("1")
+      subject.stubs(:has_graph_data).returns(true)
+      [subject]
+    end
+
+    def create_row_data(values)
+      row_data = mock
+      values.each do |key,value|
+        row_data.stubs(key).returns(value)
+      end
+      row_data
+    end
+
+  end
+end