pulse_meter-dygraphs_visualizer 0.4.15

data/spec/pulse_meter/dygraphs_visualize/dsl/widgets/stack_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe PulseMeter::DygraphsVisualize::DSL::Widgets::Stack do
+  it_should_behave_like "dsl widget"
+
+  let(:interval){ 100 }
+  let(:name) { "some_sensor" }
+  let!(:sensor){ PulseMeter::Sensor::Timelined::Max.new(name, :ttl => 1000, :interval => interval) }
+  
+  let(:widget_name){ "some_widget" }
+  let(:w){ described_class.new(widget_name)  }
+
+  describe "#to_data" do
+    let(:data){ w.to_data }
+
+    it "should produce PulseMeter::DygraphsVisualize::Widgets::Stack class" do
+      data.should be_kind_of(PulseMeter::DygraphsVisualize::Widgets::Stack)
+    end
+
+    describe "dygraphs_options" do
+      let(:dygraphs_options){ data.dygraphs_options }
+
+      it "should set stack Dygraphs options" do
+        dygraphs_options[:stacked_graph].should be_true
+        dygraphs_options[:stacked_graph_na_n_fill].should == 'inside'
+      end
+    end
+  end
+
+  describe "#values_label" do
+    it "should set values_label" do
+      w.values_label "some y-axis legend"
+      w.to_data.values_label.should == "some y-axis legend"
+    end
+  end
+
+  describe "#show_last_point" do
+    it "should set show_last_point" do
+      w.show_last_point true
+      w.to_data.show_last_point.should be_true
+    end
+  end
+
+  describe "#timespan" do
+    it "should set timespan" do
+      w.timespan 5
+      w.to_data.timespan.should == 5
+    end
+    it "should raise exception if timespan is negative" do
+      expect{ w.timespan(-1) }.to raise_exception(PulseMeter::DygraphsVisualize::DSL::BadWidgetTimeSpan)
+    end
+  end
+
+end
+

data/spec/pulse_meter/dygraphs_visualize/layout_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe PulseMeter::DygraphsVisualize::Layout do
+  let(:layout) do
+    l = PulseMeter::DygraphsVisualize::DSL::Layout.new
+    l.page "page1" do |p|
+      p.line "w1"
+      p.line "w2"
+      p.dygraphs_options({a: 1})
+    end
+    l.page "page2" do |p|
+      p.line "w3"
+      p.line "w4"
+    end
+    l.to_data
+  end
+
+  describe "#page_infos" do
+    it "should return list of page infos with ids" do
+      layout.page_infos.should == [
+        {title: "page1", id: 1, dygraphs_options: {a: 1}},
+        {title: "page2", id: 2, dygraphs_options: {}}
+      ]
+    end
+  end
+
+  describe "#options" do
+    it "should return layout options" do
+      ldsl = PulseMeter::DygraphsVisualize::DSL::Layout.new
+      ldsl.use_utc true
+      ldsl.dygraphs_options({a: 1})
+      l = ldsl.to_data
+      l.options.should == {use_utc: true, dygraphs_options: {a: 1}}
+    end
+  end
+
+  describe "#widget" do
+    it "should return data for correct widget" do
+      w = layout.widget(1, 0)
+      w.should include(id: 1, title: "w3")
+      w = layout.widget(0, 1, timespan: 123)
+      w.should include(id: 2, title: "w2")
+    end
+  end
+
+  describe "#widgets" do
+    it "should return data for correct widgets of a page" do
+      datas = layout.widgets(1)
+      datas[0].should include(id: 1, title: "w3")
+      datas[1].should include(id: 2, title: "w4")
+    end
+  end
+
+end

data/spec/pulse_meter/dygraphs_visualize/page_spec.rb

@@ -0,0 +1,145 @@
+require "spec_helper"
+
+describe PulseMeter::DygraphsVisualize::Page do
+  let(:interval){ 100 }
+  let!(:a_sensor){ PulseMeter::Sensor::Timelined::Counter.new(:a_sensor, :ttl => 1000, :interval => interval, annotation: 'A') }
+  let!(:b_sensor){ PulseMeter::Sensor::Timelined::Counter.new(:b_sensor, :ttl => 1000, :interval => interval, annotation: 'B') }
+
+  let(:type) { :some_type }
+  let(:widget_name){ "some_widget" }
+
+  let(:redraw_interval){5}
+  let(:values_label){'xxxx'}
+  let(:width){6}
+  let(:show_last_point){false}
+  let(:timespan){interval * 2}
+  let(:a_color){'#FF0000'}
+  let(:b_color){'#FFFF00'}
+
+  let(:interval_start){ Time.at((Time.now.to_i / interval) * interval) }
+  let(:page_title){"Dashboard"}
+
+
+  let(:page) do
+    p = PulseMeter::DygraphsVisualize::DSL::Page.new(page_title)
+    p.line(widget_name) do |w|
+      w.redraw_interval redraw_interval
+      w.values_label values_label
+      w.width width
+      w.show_last_point show_last_point
+      w.timespan timespan
+
+      w.sensor :a_sensor, color: a_color
+      w.sensor :b_sensor, color: b_color
+    end
+    p.line(widget_name) do |w|
+      w.redraw_interval redraw_interval
+      w.values_label values_label
+      w.width width
+      w.show_last_point show_last_point
+      w.timespan timespan
+
+      w.sensor :a_sensor, color: a_color
+      w.sensor :b_sensor, color: b_color
+    end
+    p.to_data
+  end
+
+  before(:each) do
+    Timecop.freeze(interval_start + 1) do
+      a_sensor.event(12)
+      b_sensor.event(33)
+    end
+    Timecop.freeze(interval_start + interval + 1) do
+      a_sensor.event(111)
+    end
+  end
+
+  describe "#widget_data" do
+
+    it "should generate correct data of single widget" do
+      Timecop.freeze(interval_start + 2 * interval - 1) do
+        page.widget_data(0)[:id].should == 1
+        page.widget_data(1)[:id].should == 2
+      end
+    end
+
+    it "should generate correct data of single widget" do
+      Timecop.freeze(interval_start + 2 * interval - 1) do
+        page.widget_data(0)[:series].should ==
+          {
+            titles: [a_sensor.annotation, b_sensor.annotation],
+            rows: [[interval_start.to_i * 1000, 12, 33]],
+            options: [
+              {color: a_color},
+              {color: b_color}
+            ]
+          }
+        page.widget_data(1)[:series].should ==
+          {
+            titles: [a_sensor.annotation, b_sensor.annotation],
+            rows: [[interval_start.to_i * 1000, 12, 33]],
+            options: [
+              {color: a_color},
+              {color: b_color}
+            ]
+          }
+      end
+
+      Timecop.freeze(interval_start + 2 * interval - 1) do
+        page.widget_data(0, timespan: 0)[:series].should ==
+          {
+            titles: [a_sensor.annotation, b_sensor.annotation],
+            rows: [],
+            options: [
+              {color: a_color},
+              {color: b_color}
+            ]
+          }
+        page.widget_data(1, timespan: 1)[:series].should ==
+          {
+            titles: [a_sensor.annotation, b_sensor.annotation],
+            rows: [],
+            options: [
+              {color: a_color},
+              {color: b_color}
+            ]
+          }
+
+      end
+    end
+  end
+
+  describe "#widget_datas" do
+    it "should generate correct ids for all widgets" do
+      Timecop.freeze(interval_start + 2 * interval - 1) do
+        page.widget_datas.map{|h| h[:id]}.should == [1,2]
+      end
+    end
+
+    it "should generate correct series data of all widgets" do
+      Timecop.freeze(interval_start + 2 * interval - 1) do
+
+        page.widget_datas.map{|h| h[:series]}.should == [
+          {
+            titles: [a_sensor.annotation, b_sensor.annotation],
+            rows: [[interval_start.to_i * 1000, 12, 33]],
+            options: [
+              {color: a_color},
+              {color: b_color}
+            ]
+          },
+          {
+            titles: [a_sensor.annotation, b_sensor.annotation],
+            rows: [[interval_start.to_i * 1000, 12, 33]],
+            options: [
+              {color: a_color},
+              {color: b_color}
+            ]
+          }
+        ]
+      end
+
+    end
+  end
+end

data/spec/pulse_meter/dygraphs_visualize/sensor_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+describe PulseMeter::DygraphsVisualize::Sensor do
+  let(:interval){ 100 }
+  let(:name) { "some_sensor" }
+  let(:annotation) { 'sensor descr' }
+  let!(:real_sensor){ PulseMeter::Sensor::Timelined::Counter.new(name, ttl: 1000, interval: interval, annotation: annotation) }
+  let(:sensor) { described_class.new(name: name) }
+
+  let(:color){ '#ABCDEF' }
+  let(:sensor_with_color) { described_class.new(name: name, color: color) }
+
+  let(:bad_sensor) { described_class.new(name: "bad_sensor_name") }
+  let(:interval_start){ Time.at((Time.now.to_i / interval) * interval) }
+
+  describe '#last_value' do
+    context "when sensor does not exist" do
+      it "should raise RestoreError" do
+        expect{ bad_sensor.last_value(Time.now) }.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+
+    context "when sensor has no data" do
+      it "should return nil" do
+        sensor.last_value(Time.now).should be_nil
+      end
+    end
+
+    context "when sensor has data" do
+      context "when need_incomplete arg is true" do
+        it "should return last value" do
+          Timecop.freeze(interval_start) do
+            real_sensor.event(101)
+          end
+          Timecop.freeze(interval_start+1) do
+            sensor.last_value(Time.now, true).should == 101
+          end
+        end
+      end
+
+      context "when need_incomplete arg is false" do
+        it "should return last complete value" do
+          Timecop.freeze(interval_start) do
+            real_sensor.event(101)
+          end
+          Timecop.freeze(interval_start + 1) do
+            sensor.last_value(Time.now).should be_nil
+          end
+          Timecop.freeze(interval_start + interval + 1) do
+            sensor.last_value(Time.now).should == 101
+          end
+        end
+      end
+
+    end
+  end
+
+  describe "#last_point_data" do
+
+    context "when sensor does not exist" do
+      it "should raise RestoreError" do
+        expect{ bad_sensor.last_point_data(Time.now) }.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+    it "should return last value with annotation (and color)" do
+      Timecop.freeze(interval_start) do
+        real_sensor.event(101)
+      end
+      Timecop.freeze(interval_start + 1) do
+        sensor.last_point_data(Time.now, true).should == [{name: annotation, y: 101}]
+        sensor.last_point_data(Time.now).should == [{name: annotation, y: nil}]
+        sensor_with_color.last_point_data(Time.now, true).should == [{name: annotation, y: 101, color: color}]
+        sensor_with_color.last_point_data(Time.now).should == [{name: annotation, y: nil, color: color}]
+      end
+    end
+  end
+
+  describe "#timeline_data" do
+    before(:each) do
+      Timecop.freeze(interval_start) do
+        real_sensor.event(101)
+      end
+      Timecop.freeze(interval_start + interval) do
+        real_sensor.event(55)
+      end
+    end
+
+    context "when sensor does not exist" do
+      it "should raise RestoreError" do
+        expect{ bad_sensor.timeline_data(Time.now - interval, Time.now) }.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+
+    describe "returned value" do
+      it "should contain sensor annotation" do
+        Timecop.freeze(interval_start + interval + 1) do
+          sensor.timeline_data(Time.now - interval, Time.now).first[:name].should == annotation
+        end
+      end
+      it "should contain sensor color" do
+        Timecop.freeze(interval_start + interval + 1) do
+          sensor_with_color.timeline_data(Time.now - interval, Time.now).first[:color].should == color
+        end
+      end
+
+      it "should contain [interval_start, value] pairs for each interval" do
+        Timecop.freeze(interval_start + interval + 1) do
+          data = sensor.timeline_data(Time.now - interval * 2, Time.now)
+          data.first[:data].should == [{x: interval_start.to_i * 1000, y: 101}]
+          data = sensor.timeline_data(Time.now - interval * 2, Time.now, true)
+          data.first[:data].should == [{x: interval_start.to_i * 1000, y: 101}, {x: (interval_start + interval).to_i * 1000, y: 55}]
+        end
+      end
+    end
+  end
+
+end

data/spec/pulse_meter/dygraphs_visualize/series_extractor_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe PulseMeter::DygraphsVisualize::SeriesExtractor do
+  let(:interval){ 100 }
+  let!(:real_simple_sensor){ PulseMeter::Sensor::Timelined::Counter.new(:simple_sensor,
+    ttl: 1000,
+    interval: interval,
+    annotation: 'simple sensor'
+  ) }
+  let!(:real_hashed_sensor){ PulseMeter::Sensor::Timelined::HashedCounter.new(:hashed_sensor,
+    ttl: 1000,
+    interval: interval,
+    annotation: 'hashed sensor'
+  ) }
+
+  let!(:simple_sensor){PulseMeter::DygraphsVisualize::Sensor.new(name: :simple_sensor)}
+  let!(:hashed_sensor){PulseMeter::DygraphsVisualize::Sensor.new(name: :hashed_sensor)}
+
+  describe "simple extractor" do
+
+    let(:extractor) {PulseMeter::DygraphsVisualize.extractor(simple_sensor)}
+
+    it "should be created for simple sensors" do
+      extractor.should be_kind_of(PulseMeter::DygraphsVisualize::SeriesExtractor::Simple)
+    end
+
+    it "should create point data correctly" do
+      extractor.point_data(123).should == [{y: 123, name: 'simple sensor'}]
+    end
+
+    it "should create timeline data correctly" do
+      tl_data = [
+        PulseMeter::SensorData.new(Time.at(1), 11),
+        PulseMeter::SensorData.new(Time.at(2), "22")
+      ]
+      extractor.series_data(tl_data).should == [{
+        name: 'simple sensor',
+        data: [{x: 1000, y: 11}, {x: 2000, y: 22}]
+      }]
+    end
+
+  end
+
+  describe "hash extractor" do
+    let(:extractor) {PulseMeter::DygraphsVisualize.extractor(hashed_sensor)}
+
+    it "should be created for hash sensors" do
+      extractor.should be_kind_of(PulseMeter::DygraphsVisualize::SeriesExtractor::Hashed)
+    end
+
+    it "should create point data correctly" do
+      extractor.point_data('{"x": 123, "y": 321}').should == [
+        {y: 123, name: 'hashed sensor: x'},
+        {y: 321, name: 'hashed sensor: y'}
+      ]
+    end
+
+    it "should create timeline data correctly" do
+      tl_data = [
+        PulseMeter::SensorData.new(Time.at(1), {"a" => 5, "b" => 6}),
+        PulseMeter::SensorData.new(Time.at(2), '{"c": 7, "b": 6}')
+      ]
+      extractor.series_data(tl_data).should == [
+        {
+          name: 'hashed sensor: a',
+          data: [{x: 1000, y: 5}, {x: 2000, y: nil}]
+        },
+        {
+          name: 'hashed sensor: b',
+          data: [{x: 1000, y: 6}, {x: 2000, y: 6}]
+        },
+        {
+          name: 'hashed sensor: c',
+          data: [{x: 1000, y: nil}, {x: 2000, y: 7}]
+        }
+      ]
+    end
+  end
+
+end