pulse_meter_visualizer 0.4.20 → 0.4.21

data/spec/pulse_meter/visualize/page_spec.rb

@@ -57,16 +57,16 @@ describe PulseMeter::Visualize::Page do
 
   describe "#widget_data" do
 
-    it "should generate correct data of single widget" do
+    it "generates 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
+        expect(page.widget_data(0)[:id]).to eq(1)
+        expect(page.widget_data(1)[:id]).to eq(2)
       end
     end
 
-    it "should generate correct data of single widget" do
+    it "generates correct data of single widget" do
       Timecop.freeze(interval_start + 2 * interval - 1) do
-        page.widget_data(0)[:series].should ==
+        expect(page.widget_data(0)[:series]).to eq(
           {
             data: [
               [a_sensor.annotation, 12],
@@ -77,7 +77,8 @@ describe PulseMeter::Visualize::Page do
               {color: b_color}
             ]
           }
-        page.widget_data(1)[:series].should ==
+        )
+        expect(page.widget_data(1)[:series]).to eq(
           {
             titles: [a_sensor.annotation, b_sensor.annotation],
             rows: [[interval_start.to_i * 1000, 12, 33]],
@@ -86,10 +87,11 @@ describe PulseMeter::Visualize::Page do
               {color: b_color}
             ]
           }
+        )
       end
 
       Timecop.freeze(interval_start + 2 * interval - 1) do
-        page.widget_data(0, timespan: 0)[:series].should ==
+        expect(page.widget_data(0, timespan: 0)[:series]).to eq(
           {
             data: [
               [a_sensor.annotation, 12],
@@ -100,7 +102,8 @@ describe PulseMeter::Visualize::Page do
               {color: b_color}
             ]
           }
-        page.widget_data(1, timespan: 1)[:series].should ==
+        )
+        expect(page.widget_data(1, timespan: 1)[:series]).to eq(
           {
             titles: [a_sensor.annotation, b_sensor.annotation],
             rows: [],
@@ -109,6 +112,7 @@ describe PulseMeter::Visualize::Page do
               {color: b_color}
             ]
           }
+        )
 
       end
 
@@ -117,16 +121,16 @@ describe PulseMeter::Visualize::Page do
   end
 
   describe "#widget_datas" do
-    it "should generate correct ids for all widgets" do
+    it "generates correct ids for all widgets" do
       Timecop.freeze(interval_start + 2 * interval - 1) do
-        page.widget_datas.map{|h| h[:id]}.should == [1,2]
+        expect(page.widget_datas.map{|h| h[:id]}).to eq([1,2])
       end
     end
 
-    it "should generate correct series data of all widgets" do
+    it "generates correct series data of all widgets" do
       Timecop.freeze(interval_start + 2 * interval - 1) do
 
-        page.widget_datas.map{|h| h[:series]}.should == [
+        expect(page.widget_datas.map{|h| h[:series]}).to eq([
           {
             data: [
               [a_sensor.annotation, 12],
@@ -145,7 +149,7 @@ describe PulseMeter::Visualize::Page do
               {color: b_color}
             ]
           }
-        ]
+        ])
       end
 
     end

data/spec/pulse_meter/visualize/sensor_spec.rb

@@ -15,40 +15,40 @@ describe PulseMeter::Visualize::Sensor do
 
   describe '#last_value' do
     context "when sensor does not exist" do
-      it "should raise RestoreError" do
+      it "raises 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
+      it "returns nil" do
+        expect(sensor.last_value(Time.now)).to be_nil
       end
     end
 
     context "when sensor has data" do
       context "when need_incomplete arg is true" do
-        it "should return last value" do
+        it "returns 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
+            expect(sensor.last_value(Time.now, true)).to eq(101)
           end
         end
       end
 
       context "when need_incomplete arg is false" do
-        it "should return last complete value" do
+        it "returns 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
+            expect(sensor.last_value(Time.now)).to be_nil
           end
           Timecop.freeze(interval_start + interval + 1) do
-            sensor.last_value(Time.now).should == 101
+            expect(sensor.last_value(Time.now)).to eq(101)
           end
         end
       end
@@ -59,20 +59,20 @@ describe PulseMeter::Visualize::Sensor do
   describe "#last_point_data" do
 
     context "when sensor does not exist" do
-      it "should raise RestoreError" do
+      it "raises 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
+    it "returns 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}]
+        expect(sensor.last_point_data(Time.now, true)).to eq([{name: annotation, y: 101}])
+        expect(sensor.last_point_data(Time.now)).to eq([{name: annotation, y: nil}])
+        expect(sensor_with_color.last_point_data(Time.now, true)).to eq([{name: annotation, y: 101, color: color}])
+        expect(sensor_with_color.last_point_data(Time.now)).to eq([{name: annotation, y: nil, color: color}])
       end
     end
   end
@@ -81,11 +81,11 @@ describe PulseMeter::Visualize::Sensor do
     subject{ checked_sensor.valid? }
     context "when sensor exists" do
       let(:checked_sensor){ sensor }
-      it{ should == true }
+      it{ is_expected.to eq(true) }
     end
     context "when sensor does not exist" do
       let(:checked_sensor){ bad_sensor }
-      it{ should == false }
+      it{ is_expected.to eq(false) }
     end
   end
 
@@ -100,30 +100,30 @@ describe PulseMeter::Visualize::Sensor do
     end
 
     context "when sensor does not exist" do
-      it "should raise RestoreError" do
+      it "raises 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
+      it "contains sensor annotation" do
         Timecop.freeze(interval_start + interval + 1) do
-          sensor.timeline_data(Time.now - interval, Time.now).first[:name].should == annotation
+          expect(sensor.timeline_data(Time.now - interval, Time.now).first[:name]).to eq(annotation)
         end
       end
-      it "should contain sensor color" do
+      it "contains sensor color" do
         Timecop.freeze(interval_start + interval + 1) do
-          sensor_with_color.timeline_data(Time.now - interval, Time.now).first[:color].should == color
+          expect(sensor_with_color.timeline_data(Time.now - interval, Time.now).first[:color]).to eq(color)
         end
       end
 
-      it "should contain [interval_start, value] pairs for each interval" do
+      it "contains [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}]
+          expect(data.first[:data]).to eq([{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}]
+          expect(data.first[:data]).to eq([{x: interval_start.to_i * 1000, y: 101}, {x: (interval_start + interval).to_i * 1000, y: 55}])
         end
       end
     end

data/spec/pulse_meter/visualize/series_extractor_spec.rb

@@ -20,23 +20,23 @@ describe PulseMeter::Visualize::SeriesExtractor 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)
+    it "is created for simple sensors" do
+      expect(extractor).to 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'}]
+    it "creates point data correctly" do
+      expect(extractor.point_data(123)).to eq([{y: 123, name: 'simple sensor'}])
     end
 
-    it "should create timeline data correctly" do
+    it "creates 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 == [{
+      expect(extractor.series_data(tl_data)).to eq([{
         name: 'simple sensor',
         data: [{x: 1000, y: 11}, {x: 2000, y: 22}]
-      }]
+      }])
     end
 
   end
@@ -44,23 +44,23 @@ describe PulseMeter::Visualize::SeriesExtractor do
   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)
+    it "is created for hash sensors" do
+      expect(extractor).to be_kind_of(PulseMeter::Visualize::SeriesExtractor::Hashed)
     end
 
-    it "should create point data correctly" do
-      extractor.point_data('{"x": 123, "y": 321}').should == [
+    it "creates point data correctly" do
+      expect(extractor.point_data('{"x": 123, "y": 321}')).to eq([
         {y: 123, name: 'hashed sensor: x'},
         {y: 321, name: 'hashed sensor: y'}
-      ]
+      ])
     end
 
-    it "should create timeline data correctly" do
+    it "creates 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 == [
+      expect(extractor.series_data(tl_data)).to eq([
         {
           name: 'hashed sensor: a',
           data: [{x: 1000, y: 5}, {x: 2000, y: nil}]
@@ -73,7 +73,7 @@ describe PulseMeter::Visualize::SeriesExtractor do
           name: 'hashed sensor: c',
           data: [{x: 1000, y: nil}, {x: 2000, y: 7}]
         }
-      ]
+      ])
     end
   end
 

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

@@ -26,13 +26,13 @@ describe PulseMeter::Visualize::Widgets::Gauge do
   end
 
   describe "#data" do
-    it "should contain type, title, redraw_interval, width, gchart_options attriutes" do
+    it "contains 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}
+      expect(wdata[:type]).to eq('gauge')
+      expect(wdata[:title]).to eq(widget_name)
+      expect(wdata[:redraw_interval]).to eq(redraw_interval)
+      expect(wdata[:width]).to eq(width)
+      expect(wdata[:gchart_options]).to eq({a: 1})
     end
 
     describe "series attribute" do
@@ -43,14 +43,14 @@ describe PulseMeter::Visualize::Widgets::Gauge do
         c_sensor.event(:b => 55)
       end
 
-      it "should contain valid gauge slices" do
+      it "contains valid gauge slices" do
 
-        widget.data[:series].sort.should == [
+        expect(widget.data[:series].sort).to eq([
           ['A', 12],
           ['B', 33],
           ["C: a", 44],
           ["C: b", 55]
-        ].sort
+        ].sort)
 
       end
 

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

@@ -26,13 +26,13 @@ describe PulseMeter::Visualize::Widgets::Pie do
   end
 
   describe "#data" do
-    it "should contain type, title, redraw_interval, width, gchart_options attriutes" do
+    it "contains 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}
+      expect(wdata[:type]).to eq('pie')
+      expect(wdata[:title]).to eq(widget_name)
+      expect(wdata[:redraw_interval]).to eq(redraw_interval)
+      expect(wdata[:width]).to eq(width)
+      expect(wdata[:gchart_options]).to eq({a: 1})
     end
 
     describe "series attribute" do
@@ -47,10 +47,10 @@ describe PulseMeter::Visualize::Widgets::Pie do
         @current_time = interval_start + 2 * interval - 1
       end
 
-      it "should contain valid pie slices" do
+      it "contains valid pie slices" do
 
         Timecop.freeze(@current_time) do
-          widget.data[:series].should ==
+          expect(widget.data[:series]).to eq(
             {
               data: [
                 [a_sensor.annotation, 12],
@@ -61,6 +61,7 @@ describe PulseMeter::Visualize::Widgets::Pie do
                 {color: b_color}
               ]
             }
+          )
         end
 
       end

data/spec/pulse_meter/visualizer_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe PulseMeter::Visualizer do
   describe "::draw" do
-    it "should generate correct layout with passed block" do
+    it "generates correct layout with passed block" do
       layout = described_class.draw do |l|
 
         l.title "My Gauges"
@@ -26,7 +26,7 @@ describe PulseMeter::Visualizer do
           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
@@ -35,7 +35,7 @@ describe PulseMeter::Visualizer do
         end
 
       end
-      layout.should be_kind_of(PulseMeter::Visualize::Layout)
+      expect(layout).to be_kind_of(PulseMeter::Visualize::Layout)
     end
   end
 end

data/spec/shared_examples/dsl_widget.rb

@@ -8,33 +8,33 @@ shared_examples_for "dsl widget" do
   let(:w){ described_class.new(widget_name)  }
 
   describe '.new' do
-    it "should set default value for width papram" do
+    it "sets default value for width papram" do
       wid = w.to_data
-      wid.width.should == PulseMeter::Visualize::DSL::Widget::MAX_WIDTH
+      expect(wid.width).to eq(PulseMeter::Visualize::DSL::Widget::MAX_WIDTH)
     end
 
-    it "should set title param from .new argument" do
+    it "sets title param from .new argument" do
       wid = w.to_data
-      wid.title.should == widget_name
+      expect(wid.title).to eq(widget_name)
     end
   end
 
   describe "#process_args" do
-    it "should set sensor by :sensor param" do
+    it "sets sensor by :sensor param" do
       w.process_args :sensor => :some_sensor
       sensors = w.to_data.sensors
-      sensors.size.should == 1
-      sensors.first.name.to_s.should == 'some_sensor'
+      expect(sensors.size).to eq(1)
+      expect(sensors.first.name.to_s).to eq('some_sensor')
     end
 
-    it "should set title by :title param" do
+    it "sets title by :title param" do
       w.process_args :title => 'Title XXX'
-      w.to_data.title.should == 'Title XXX'
+      expect(w.to_data.title).to eq('Title XXX')
     end
 
-    it "should set width by :width param" do
+    it "sets width by :width param" do
       w.process_args :width => 5
-      w.to_data.width.should == 5
+      expect(w.to_data.width).to eq(5)
     end
 
   end
@@ -44,66 +44,66 @@ shared_examples_for "dsl widget" do
     let!(:s2){ PulseMeter::Sensor::Timelined::Max.new('s2', :ttl => 1000, :interval => interval) }
 
 
-    it "should add sensor" do
+    it "adds 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'
+      expect(sensors.size).to eq(2)
+      expect(sensors.first.name.to_s).to eq('s1')
+      expect(sensors.last.name.to_s).to eq('s2')
     end
   end
 
   describe "#title" do
-    it "should set title" do
+    it "sets title" do
       w.title 'Title XXX'
-      w.to_data.title.should == 'Title XXX'
+      expect(w.to_data.title).to eq('Title XXX')
       w.title 'Title YYY'
-      w.to_data.title.should == 'Title YYY'
+      expect(w.to_data.title).to eq('Title YYY')
     end
   end
 
   describe "#width" do
-    it "should set width" do
+    it "sets width" do
       w.width 6
-      w.to_data.width.should == 6
+      expect(w.to_data.width).to eq(6)
     end
 
-    it "should raise exception if width is invalid" do
+    it "raises exception if width is invalid" do
       expect { w.width -1 }.to raise_exception(PulseMeter::Visualize::DSL::BadWidgetWidth)
       expect { w.width 13 }.to raise_exception(PulseMeter::Visualize::DSL::BadWidgetWidth)
     end
   end
 
   describe "#redraw_interval" do
-    it "should set redraw_interval" do
+    it "sets redraw_interval" do
       w.redraw_interval 5
-      w.to_data.redraw_interval.should == 5
+      expect(w.to_data.redraw_interval).to eq(5)
     end
-    it "should raise exception if redraw_interval is negative" do
+    it "raises 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)
+    it "converts dsl data to widget" do
+      expect(w.to_data).to be_kind_of(PulseMeter::Visualize::Widget)
     end
   end
 
   describe "#gchart_options" do
-    it "should add options to gchart_options hash" do
+    it "adds 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}
+      expect(w.to_data.gchart_options).to eq({a: 1, b: 2})
     end
   end
 
   describe "any anknown method" do
-    it "should add options to gchart_options hash" do
+    it "adds options to gchart_options hash" do
       w.foobar 123
-      w.to_data.gchart_options.should == {foobar: 123}
+      expect(w.to_data.gchart_options).to eq({foobar: 123})
     end
   end
 end