pulse-meter 0.4.9 → 0.4.11

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

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe PulseMeter::Visualize::DSL::Widgets::Pie 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
-    it "should produce PulseMeter::Visualize::Widgets::Pie class" do
-      w.to_data.should be_kind_of(PulseMeter::Visualize::Widgets::Pie)
-    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
-
-end
-
-

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe PulseMeter::Visualize::DSL::Widgets::Table 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
-    it "should produce PulseMeter::Visualize::Widgets::Area class" do
-      w.to_data.should be_kind_of(PulseMeter::Visualize::Widgets::Table)
-    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::Visualize::DSL::BadWidgetTimeSpan)
-    end
-  end
-end
-

data/spec/pulse_meter/visualize/layout_spec.rb

@@ -1,54 +0,0 @@
-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.line "w2"
-      p.gchart_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, gchart_options: {a: 1}},
-        {title: "page2", id: 2, gchart_options: {}}
-      ]
-    end
-  end
-
-  describe "#options" do
-    it "should return layout options" do
-      ldsl = PulseMeter::Visualize::DSL::Layout.new
-      ldsl.use_utc true
-      ldsl.gchart_options({a: 1})
-      l = ldsl.to_data
-      l.options.should == {use_utc: true, gchart_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/visualize/page_spec.rb

@@ -1,153 +0,0 @@
-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_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 ==
-          {
-            data: [
-              [a_sensor.annotation, 12],
-              [b_sensor.annotation, 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 ==
-          {
-            data: [
-              [a_sensor.annotation, 12],
-              [b_sensor.annotation, 33]
-            ],
-            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 == [
-          {
-            data: [
-              [a_sensor.annotation, 12],
-              [b_sensor.annotation, 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/visualize/sensor_spec.rb

@@ -1,120 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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