pulse-meter 0.0.1

data/spec/pulse_meter/sensor/timelined/hashed_counter_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::HashedCounter do
+  it_should_behave_like "timeline sensor", {}, {:foo => 1}
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => 2}], {:foo => 3}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => :bad_value}], {:foo => 1}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:boo => 2}], {:foo => 1, :boo => 2}.to_json
+end

data/spec/pulse_meter/sensor/timelined/max_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::Max do
+  it_should_behave_like "timeline sensor"
+  it_should_behave_like "timelined subclass", [1, 2, -1, -1, 5, 0], 5
+  it_should_behave_like "timelined subclass", [1], 1
+end

data/spec/pulse_meter/sensor/timelined/median_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::Median do
+  it_should_behave_like "timeline sensor"
+  it_should_behave_like "timelined subclass", [5, 4, 3, 2, 1], 3
+  it_should_behave_like "timelined subclass", [1], 1
+end

data/spec/pulse_meter/sensor/timelined/min_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::Min do
+  it_should_behave_like "timeline sensor"
+  it_should_behave_like "timelined subclass", [1, 2, -1, -1, 5, 0], -1
+  it_should_behave_like "timelined subclass", [1], 1
+end

data/spec/pulse_meter/sensor/timelined/percentile_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::Percentile do
+  it_should_behave_like "timeline sensor", {:p => 0.8}
+  it_should_behave_like "timelined subclass", [5, 4, 2, 2, 2, 2, 2, 2, 2, 1], 2, {:p => 0.8}
+  it_should_behave_like "timelined subclass", [1], 1, {:p => 0.8}
+  
+  let(:init_values) {{:ttl => 1, :raw_data_ttl => 1, :interval => 1, :reduce_delay => 1}}
+  let(:name) {"percentile"}
+
+  it "should raise exception when percentile is not between 0 and 1" do
+    expect {described_class.new(name, init_values.merge({:p => -1}))}.to raise_exception(ArgumentError) 
+    expect {described_class.new(name, init_values.merge({:p => 1.1}))}.to raise_exception(ArgumentError) 
+    expect {described_class.new(name, init_values.merge({:p => 0.1}))}.not_to raise_exception(ArgumentError) 
+  end
+
+end

data/spec/pulse_meter/visualize/app_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe PulseMeter::Visualize::App do
+  include Rack::Test::Methods
+  before(:each) do
+    @layout = PulseMeter::Visualizer.draw do |l|
+      l.title "Foo meters"
+      l.page "Foo page" do
+      end
+    end
+  end
+
+  def app
+    PulseMeter::Visualize::App.new(@layout)
+  end
+  
+  it "responds to /" do
+    get '/'
+    last_response.should be_ok
+    last_response.body.should include("Foo meters")
+  end
+
+  it "responds to /application.js" do
+    get '/js/application.js'
+    last_response.should be_ok
+  end
+end

data/spec/pulse_meter/visualize/dsl/layout_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe PulseMeter::Visualize::DSL::Layout do
+  let(:interval){ 100 }
+  let(:sensor_name) { "some_sensor" }
+  let!(:sensor){ PulseMeter::Sensor::Timelined::Max.new(sensor_name, :ttl => 1000, :interval => interval) }
+  let(:layout){ described_class.new }
+
+  describe '.new' do
+    it "should initialize pages, title, use_utc, highchart_options" do
+      l = layout.to_layout
+      l.title.should == PulseMeter::Visualize::DSL::Layout::DEFAULT_TITLE
+      l.pages.should == []
+      l.use_utc.should be_true
+      l.highchart_options.should == {}
+    end
+  end
+
+  describe "#page" do
+    it "should add page constructed by block to pages" do
+      layout.page "My Foo Page" do |p|
+        p.pie "foo_widget", sensor: sensor_name
+        p.spline "bar_widget" do |w|
+          w.sensor(sensor_name)
+        end
+      end
+      l = layout.to_layout
+      l.pages.size.should == 1
+      p = l.pages.first
+      p.title.should == "My Foo Page"
+      p.widgets.size.should == 2
+      p.widgets.first.title.should == "foo_widget"
+      p.widgets.last.title.should == "bar_widget"
+    end
+  end
+
+  describe "#title" do
+    it "should set layout title" do
+      layout.title "Foo Title"
+      layout.to_layout.title.should == 'Foo Title'
+    end
+  end
+
+  describe "#use_utc" do
+    it "should set use_utc" do
+      layout.use_utc false
+      layout.to_layout.use_utc.should be_false
+    end
+  end
+
+  describe "#highchart_options" do
+    it "should set highchart_options" do
+      layout.highchart_options({b: 1})
+      layout.to_layout.highchart_options.should == {b: 1}
+    end
+  end
+
+  describe "#to_layout" do
+    it "should convert layout dsl data to Visualize::Layout" do
+      layout.to_layout.should be_kind_of(PulseMeter::Visualize::Layout)
+    end
+  end
+end
+

data/spec/pulse_meter/visualize/dsl/page_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe PulseMeter::Visualize::DSL::Page do
+  let(:interval){ 100 }
+  let(:sensor_name) { "some_sensor" }
+  let!(:sensor){ PulseMeter::Sensor::Timelined::Max.new(sensor_name, :ttl => 1000, :interval => interval) }
+  let(:title) { "page title" }
+  let(:page){ PulseMeter::Visualize::DSL::Page.new(title) }
+
+  describe '.new' do
+    it "should initialize title and widgets" do
+      p = page.to_page  
+      p.title.should == title
+      p.widgets.should == []
+    end
+  end
+
+  describe '#widget' do
+    it "should add widget initialized by args to widgets" do
+      page.widget(:some_widget_type, :some_widget_name, sensor: sensor_name, width: 7)
+      w = page.to_page.widgets.first
+      w.width.should == 7
+      w.type.should == :some_widget_type
+      w.title.should == "some_widget_name"
+      w.sensors.first.name.should == sensor_name
+    end
+    
+    it "should add widget initialized by block" do
+      page.widget(:some_widget_type, :some_widget_name) do |w|
+        w.sensor(sensor_name)
+        w.sensor(sensor_name)
+        w.title "foo_widget"
+        w.width 7
+      end
+      w = page.to_page.widgets.first
+      w.type.should == :some_widget_type
+      w.width.should == 7
+      w.title.should == "foo_widget"
+      w.sensors.size.should == 2
+      w.sensors.first.name.should == sensor_name
+      w.sensors.last.name.should == sensor_name
+    end
+  end
+  
+  describe "#pie" do
+    it "should create widget width type :pie" do
+      page.pie(:some_widget_name)
+      w = page.to_page.widgets.first
+      w.type.should == :pie
+    end
+  end
+
+  describe "#chart" do
+    it "should create widget width type :chart" do
+      page.spline(:some_widget_name)
+      w = page.to_page.widgets.first
+      w.type.should == :spline
+    end
+  end
+
+  describe "#title" do
+    it "should set page title" do
+      page.title "Foo Title"
+      page.to_page.title.should == 'Foo Title'
+    end
+  end
+
+  describe "#to_page" do
+    it "should convert DSL data to Visualize::Page" do
+      page.to_page.should be_kind_of(PulseMeter::Visualize::Page)
+    end
+  end
+
+end
+

data/spec/pulse_meter/visualize/dsl/sensor_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe PulseMeter::Visualize::DSL::Sensor do
+  let(:interval){ 100 }
+  let(:name) { "some_sensor" }
+  let!(:sensor){ PulseMeter::Sensor::Timelined::Max.new(name, :ttl => 1000, :interval => interval) }
+
+  describe '.new' do
+    it "should save passed name and create Visualize::Sensor with it" do
+      described_class.new(name).to_sensor.name.to_s.should == name
+    end
+  end
+
+  describe '#process_args' do
+    it "should pass args transparently to Visualize::Sensor" do
+      s = described_class.new(name)
+      s.process_args :color => :red
+      s.to_sensor.color.to_s.should == 'red'
+    end
+  end
+
+  describe '#to_sensor' do
+    # actually tested above
+    it "should convert dsl data to sensor" do
+      described_class.new(name).to_sensor.should be_kind_of(PulseMeter::Visualize::Sensor)
+    end
+  end
+
+end
+

data/spec/pulse_meter/visualize/dsl/widget_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe PulseMeter::Visualize::DSL::Widget do
+  let(:interval){ 100 }
+  let(:name) { "some_sensor" }
+  let!(:sensor){ PulseMeter::Sensor::Timelined::Max.new(name, :ttl => 1000, :interval => interval) }
+  
+  let(:type) { :some_type }
+  let(:widget_name){ "some_widget" }
+  let(:w){ described_class.new(type, widget_name)  }
+
+  describe '.new' do
+    it "should raise exception if type arg is empty" do
+      lambda{ described_class.new('', widget_name) }.should raise_exception(PulseMeter::Visualize::DSL::BadWidgetType)
+    end
+
+    it "should set default values for name, title, width, values_label. redraw_interval, show_last_point paprams" do
+      wid = w.to_widget
+      wid.type.should == :some_type
+      wid.width.should == PulseMeter::Visualize::DSL::Widget::DEFAULT_WIDTH
+      wid.title.should == widget_name
+      wid.sensors.should == []
+      wid.values_label.should == ''
+      wid.redraw_interval.should be_nil
+      wid.show_last_point.should be_false
+    end
+  end
+
+  describe "#process_args" do
+    it "should set sensor by :sensor param" do
+      w.process_args :sensor => :sss
+      sensors = w.to_widget.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_widget.title.should == 'Title XXX'
+    end
+
+    it "should set width by :width param" do
+      w.process_args :width => 5
+      w.to_widget.width.should == 5
+    end
+
+    it "should set values_label by :values_label param" do
+      w.process_args :values_label => "some y-axis legend"
+      w.to_widget.values_label.should == "some y-axis legend"
+    end
+  end
+
+  describe "#sensor" do
+    it "should add sensor" do
+      w.sensor :s1
+      w.sensor :s2
+      sensors = w.to_widget.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_widget.title.should == 'Title XXX'
+      w.title 'Title YYY'
+      w.to_widget.title.should == 'Title YYY'
+    end
+  end
+
+  describe "#width" do
+    it "should set width" do
+      w.width 6
+      w.to_widget.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 "#values_label" do
+    it "should set values_label" do
+      w.values_label "some y-axis legend"
+      w.to_widget.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_widget.show_last_point.should be_true
+    end
+  end
+
+  describe "#redraw_interval" do
+    it "should set redraw_interval" do
+      w.redraw_interval 5
+      w.to_widget.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 "#timespan" do
+    it "should set timespan" do
+      w.timespan 5
+      w.to_widget.timespan.should == 5
+    end
+    it "should raise exception if timespan is negative" do
+      expect{ w.timespan(-1) }.to raise_exception(PulseMeter::Visualize::DSL::BadWidgetTimeSpan)
+    end
+
+  end
+
+  describe "#to_widget" do
+    it "should convert dsl data to widget" do
+      w.to_widget.should be_kind_of(PulseMeter::Visualize::Widget)
+    end
+  end
+end
+

data/spec/pulse_meter/visualize/layout_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::Layout do
+  let(:layout) do
+    l = PulseMeter::Visualize::DSL::Layout.new
+    l.page "page1" do |p|
+      p.line "w1"
+      p.spline "w2"
+      p.highchart_options({a: 1})
+    end
+    l.page "page2" do |p|
+      p.line "w3"
+      p.spline "w4"
+    end
+    l.to_layout
+  end
+
+  describe "#page_infos" do
+    it "should return list of page infos with ids" do
+      layout.page_infos.should == [
+        {title: "page1", id: 1, highchart_options: {a: 1}},
+        {title: "page2", id: 2, highchart_options: {}}
+      ]
+    end
+  end
+
+  describe "#options" do
+    it "should return layout options" do
+      ldsl = PulseMeter::Visualize::DSL::Layout.new
+      ldsl.use_utc true
+      ldsl.outlier_color '#RED'
+      ldsl.highchart_options({a: 1})
+      l = ldsl.to_layout
+      l.options.should == {use_utc: true, outlier_color: '#RED', highchart_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)
+      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/visualize/page_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::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::Visualize::DSL::Page.new(page_title)
+    p.pie(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_page
+  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 ==
+          [
+            {
+              type: :pie,
+              name: values_label,
+              data: [
+                {
+                  name: a_sensor.annotation,
+                  color: a_color,
+                  y: 12
+                },
+                {
+                  name: b_sensor.annotation,
+                  color: b_color,
+                  y: 33
+                }
+              ]
+
+            }
+          ]
+        page.widget_data(1)[:series].should ==
+          [{
+             name: a_sensor.annotation,
+             color: a_color,
+             data: [{x: interval_start.to_i * 1000, y: 12}]
+           }, {
+            name: b_sensor.annotation,
+            color: b_color,
+            data: [{x: interval_start.to_i * 1000, y: 33}]
+          }]
+      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 == [
+          [
+            {
+              type: :pie,
+              name: values_label,
+              data: [
+                {
+                  name: a_sensor.annotation,
+                  color: a_color,
+                  y: 12
+                },
+                {
+                  name: b_sensor.annotation,
+                  color: b_color,
+                  y: 33
+                }
+              ]
+
+            }
+          ],
+          [{
+             name: a_sensor.annotation,
+             color: a_color,
+             data: [{x: interval_start.to_i * 1000, y: 12}]
+           }, {
+            name: b_sensor.annotation,
+            color: b_color,
+            data: [{x: interval_start.to_i * 1000, y: 33}]
+          }]
+        ]
+      end
+
+
+    end
+  end
+end