pulse_meter_visualizer 0.4.11

data/spec/pulse_meter/visualize/sensor_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::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/visualize/series_extractor_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::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::Visualize::Sensor.new(name: :simple_sensor)}
+  let!(:hashed_sensor){PulseMeter::Visualize::Sensor.new(name: :hashed_sensor)}
+
+  describe "simple extractor" do
+
+    let(:extractor) {PulseMeter::Visualize.extractor(simple_sensor)}
+
+    it "should be created for simple sensors" do
+      extractor.should be_kind_of(PulseMeter::Visualize::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::Visualize.extractor(hashed_sensor)}
+
+    it "should be created for hash sensors" do
+      extractor.should be_kind_of(PulseMeter::Visualize::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

data/spec/pulse_meter/visualize/widgets/area_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::Widgets::Area do
+  it_should_behave_like "widget"
+end
+

data/spec/pulse_meter/visualize/widgets/gauge_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::Widgets::Gauge do
+  let(:interval){ 100 }
+  let!(:a_sensor){PulseMeter::Sensor::Indicator.new(:a_sensor, annotation: 'A')}
+  let!(:b_sensor){PulseMeter::Sensor::Indicator.new(:b_sensor, annotation: 'B')}
+  let!(:c_sensor){PulseMeter::Sensor::HashedIndicator.new(:c_sensor, annotation: 'C')}
+
+
+  let(:widget_name){ "some_widget" }
+
+  let(:redraw_interval){5}
+  let(:width){6}
+
+  let(:interval_start){ Time.at((Time.now.to_i / interval) * interval) }
+
+  let(:widget) do
+    w = PulseMeter::Visualize::DSL::Widgets::Gauge.new(widget_name)
+    w.redraw_interval redraw_interval
+    w.width width
+    w.sensor :a_sensor
+    w.sensor :b_sensor
+    w.sensor :c_sensor
+    w.gchart_options a: 1
+    w.to_data
+  end
+
+  describe "#data" do
+    it "should contain type, title, redraw_interval, width, gchart_options attriutes" do
+      wdata = widget.data
+      wdata[:type].should == 'gauge'
+      wdata[:title].should == widget_name
+      wdata[:redraw_interval].should == redraw_interval
+      wdata[:width].should == width
+      wdata[:gchart_options].should == {a: 1}
+    end
+
+    describe "series attribute" do
+      before(:each) do
+        a_sensor.event(12)
+        b_sensor.event(33)
+        c_sensor.event(:a => 44)
+        c_sensor.event(:b => 55)
+      end
+
+      it "should contain valid gauge slices" do
+
+        widget.data[:series].sort.should == [
+          ['A', 12],
+          ['B', 33],
+          ["C: a", 44],
+          ["C: b", 55]
+        ].sort
+
+      end
+
+    end
+  end
+end
+
+
+
+

data/spec/pulse_meter/visualize/widgets/line_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::Widgets::Line do
+  it_should_behave_like "widget"
+end
+

data/spec/pulse_meter/visualize/widgets/pie_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::Widgets::Pie 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(:widget_name){ "some_widget" }
+
+  let(:redraw_interval){5}
+  let(:values_label){'xxxx'}
+  let(:width){6}
+  let(:a_color){'#FF0000'}
+  let(:b_color){'#FFFF00'}
+
+  let(:interval_start){ Time.at((Time.now.to_i / interval) * interval) }
+
+  let(:widget) do
+    w = PulseMeter::Visualize::DSL::Widgets::Pie.new(widget_name)
+    w.redraw_interval redraw_interval
+    w.width width
+    w.sensor :a_sensor, color: a_color
+    w.sensor :b_sensor, color: b_color
+    w.gchart_options a: 1
+    w.to_data
+  end
+
+  describe "#data" do
+    it "should contain type, title, redraw_interval, width, gchart_options attriutes" do
+      wdata = widget.data
+      wdata[:type].should == 'pie'
+      wdata[:title].should == widget_name
+      wdata[:redraw_interval].should == redraw_interval
+      wdata[:width].should == width
+      wdata[:gchart_options].should == {a: 1}
+    end
+
+    describe "series attribute" do
+      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
+        @current_time = interval_start + 2 * interval - 1
+      end
+
+      it "should contain valid pie slices" do
+
+        Timecop.freeze(@current_time) do
+          widget.data[:series].should ==
+            {
+              data: [
+                [a_sensor.annotation, 12],
+                [b_sensor.annotation, 33]
+              ],
+              options: [
+                {color: a_color},
+                {color: b_color}
+              ]
+            }
+        end
+
+      end
+
+    end
+  end
+end
+
+
+

data/spec/pulse_meter/visualize/widgets/table_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::Widgets::Table do
+  it_should_behave_like "widget"
+end
+

data/spec/pulse_meter/visualizer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe PulseMeter::Visualizer do
+  describe "::draw" do
+    it "should generate correct layout with passed block" do
+      layout = described_class.draw do |l|
+
+        l.title "My Gauges"
+
+        l.page "Dashboard" do |p|
+          p.line :convertion do |c|
+            c.sensor :adv_clicks, color: :green
+            c.sensor :adv_shows, color: :red
+          end
+
+          p.pie :agents, title: 'User Agents' do |c|
+            c.sensor :agent_ie
+            c.sensor :agent_chrome
+            c.sensor :agent_ff
+            c.sensor :agent_other
+          end
+
+        end
+
+        l.page "Request stats" do |p|
+          p.line :rph_total, sensor: :rph_total
+          p.line :rph_main_page, sensor: :rph_main_page
+          p.line :request_time_p95_hour
+        
+          p.pie :success_vs_fail_total_hourly do |w|
+            w.sensor :success_total_hourly
+            w.sensor :fail_total_hourly
+          end
+
+        end
+
+      end
+      layout.should be_kind_of(PulseMeter::Visualize::Layout)
+    end
+  end
+end
+

data/spec/shared_examples/dsl_widget.rb

@@ -0,0 +1,106 @@
+shared_examples_for "dsl widget" do
+
+  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 '.new' do
+    it "should set default value for width papram" do
+      wid = w.to_data
+      wid.width.should == PulseMeter::Visualize::DSL::Widget::MAX_WIDTH
+    end
+
+    it "should set title param from .new argument" do
+      wid = w.to_data
+      wid.title.should == widget_name
+    end
+  end
+
+  describe "#process_args" do
+    it "should set sensor by :sensor param" do
+      w.process_args :sensor => :sss
+      sensors = w.to_data.sensors
+      sensors.size.should == 1
+      sensors.first.name.to_s.should == 'sss'
+    end
+
+    it "should set title by :title param" do
+      w.process_args :title => 'Title XXX'
+      w.to_data.title.should == 'Title XXX'
+    end
+
+    it "should set width by :width param" do
+      w.process_args :width => 5
+      w.to_data.width.should == 5
+    end
+
+  end
+
+  describe "#sensor" do
+    it "should add sensor" do
+      w.sensor :s1
+      w.sensor :s2
+      sensors = w.to_data.sensors
+      sensors.size.should == 2
+      sensors.first.name.to_s.should == 's1'
+      sensors.last.name.to_s.should == 's2'
+    end
+  end
+
+  describe "#title" do
+    it "should set title" do
+      w.title 'Title XXX'
+      w.to_data.title.should == 'Title XXX'
+      w.title 'Title YYY'
+      w.to_data.title.should == 'Title YYY'
+    end
+  end
+
+  describe "#width" do
+    it "should set width" do
+      w.width 6
+      w.to_data.width.should == 6
+    end
+
+    it "should raise exception if width is invalid" do
+      expect { w.width -1 }.to raise_exception(PulseMeter::Visualize::DSL::BadWidgetWidth)
+      expect { w.width 11 }.to raise_exception(PulseMeter::Visualize::DSL::BadWidgetWidth)
+    end
+  end
+
+  describe "#redraw_interval" do
+    it "should set redraw_interval" do
+      w.redraw_interval 5
+      w.to_data.redraw_interval.should == 5
+    end
+    it "should raise exception if redraw_interval is negative" do
+      expect{ w.redraw_interval(-1) }.to raise_exception(PulseMeter::Visualize::DSL::BadWidgetRedrawInterval)
+    end
+
+  end
+
+  describe "#to_data" do
+    it "should convert dsl data to widget" do
+      w.to_data.should be_kind_of(PulseMeter::Visualize::Widget)
+    end
+  end
+
+  describe "#gchart_options" do
+    it "should add options to gchart_options hash" do
+      w.gchart_options a: 1
+      w.gchart_options b: 2
+      w.to_data.gchart_options.should == {a: 1, b: 2}
+    end
+  end
+
+  describe "any anknown method" do
+    it "should add options to gchart_options hash" do
+      w.foobar 123
+      w.to_data.gchart_options.should == {foobar: 123}
+    end
+  end
+end
+