pulse_meter_core 0.5.3 → 0.5.4

data/spec/shared_examples/timeline_sensor.rb

@@ -21,14 +21,14 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
   before(:each) do
     @now = Time.now
     tc = PulseMeter::TimeConverter.new(timezone)
-    
+
     @redis_now = tc.to_redis(@now).to_i
 
     @interval_id = (@redis_now / interval) * interval
     @prev_interval_id = (@redis_now / interval) * interval - interval
 
     @raw_data_key = sensor.raw_data_key(@interval_id)
-  
+
     @prev_raw_data_key = sensor.raw_data_key(@prev_interval_id)
 
     @next_raw_data_key = sensor.raw_data_key(@interval_id + interval)
@@ -38,7 +38,7 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
   end
 
   describe "#dump" do
-    it "should be dumped succesfully" do
+    it "is dumped succesfully" do
       expect {sensor.dump!}.not_to raise_exception
     end
   end
@@ -50,35 +50,35 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
       @restored = base_class.restore(sensor.name)
     end
 
-    it "should restore #{described_class} instance" do
-      @restored.should be_instance_of(described_class)
+    it "restores #{described_class} instance" do
+      expect(@restored).to be_instance_of(described_class)
     end
 
-    it "should restore object with the same data" do
+    it "restores object with the same data" do
       def inner_data(obj)
         obj.instance_variables.sort.map {|v| obj.instance_variable_get(v)}
       end
 
-      inner_data(sensor).should == inner_data(@restored)
+      expect(inner_data(sensor)).to eq(inner_data(@restored))
     end
   end
 
   describe "#event" do
-    it "should write events to redis" do
+    it "writes events to redis" do
       expect{
         sensor.event(sample_event)
       }.to change{ redis.keys('*').count }.by(1)
     end
 
-    it "should write data so that it totally expires after :raw_data_ttl" do
+    it "writes data so that it totally expires after :raw_data_ttl" do
       key_count = redis.keys('*').count
       sensor.event(sample_event)
       Timecop.freeze(@now + raw_data_ttl + 1) do
-        redis.keys('*').count.should == key_count
+        expect(redis.keys('*').count).to eq(key_count)
       end
     end
 
-    it "should write data to bucket indicated by truncated timestamp" do
+    it "writes data to bucket indicated by truncated timestamp" do
       expect{
         Timecop.freeze(@start_of_interval) do
           sensor.event(sample_event)
@@ -87,32 +87,32 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
     end
 
     it "returns true if event processed correctly" do
-      sensor.event(sample_event).should be
+      expect(sensor.event(sample_event)).to be
     end
 
     it "catches StandardErrors and returns false" do
-      sensor.stub(:aggregate_event) {raise StandardError}
-      sensor.event(sample_event).should_not be
+      allow(sensor).to receive(:aggregate_event) {raise StandardError}
+      expect(sensor.event(sample_event)).not_to be
     end
   end
 
   describe "#event_at" do
     let(:now) {@now}
-    it "should write events to redis" do
+    it "writes events to redis" do
       expect{
           sensor.event_at(now, sample_event)
       }.to change{ redis.keys('*').count }.by(1)
     end
 
-    it "should write data so that it totally expires after :raw_data_ttl" do
+    it "writes data so that it totally expires after :raw_data_ttl" do
       key_count = redis.keys('*').count
       sensor.event_at(now, sample_event)
       Timecop.freeze(now + raw_data_ttl + 1) do
-        redis.keys('*').count.should == key_count
+        expect(redis.keys('*').count).to eq(key_count)
       end
     end
 
-    it "should write data to bucket indicated by passed time" do
+    it "writes data to bucket indicated by passed time" do
       expect{
         Timecop.freeze(@start_of_interval) do
           sensor.event_at(@start_of_prev_interval, sample_event)
@@ -122,65 +122,65 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
   end
 
   describe "#summarize" do
-    it "should convert data stored by raw_data_key to a value defined only by stored data" do
+    it "converts data stored by raw_data_key to a value defined only by stored data" do
       Timecop.freeze(@start_of_interval) do
         sensor.event(sample_event)
       end
       Timecop.freeze(@start_of_interval + interval) do
         sensor.event(sample_event)
       end
-      sensor.summarize(@raw_data_key).should == sensor.summarize(@next_raw_data_key)
-      sensor.summarize(@raw_data_key).should_not be_nil
+      expect(sensor.summarize(@raw_data_key)).to eq(sensor.summarize(@next_raw_data_key))
+      expect(sensor.summarize(@raw_data_key)).not_to be_nil
     end
   end
 
   describe "#reduce" do
-    it "should store summarized value into data_key" do
+    it "stores summarized value into data_key" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       val = sensor.summarize(@raw_data_key)
-      val.should_not be_nil
+      expect(val).not_to be_nil
       sensor.reduce(@interval_id)
-      redis.get(sensor.data_key(@interval_id)).should == val.to_s
+      expect(redis.get(sensor.data_key(@interval_id))).to eq(val.to_s)
     end
 
-    it "should remove original raw_data_key" do
+    it "removes original raw_data_key" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       expect{
         sensor.reduce(@interval_id)
       }.to change{ redis.keys(sensor.raw_data_key(@interval_id)).count }.from(1).to(0)
     end
 
-    it "should expire stored summarized data" do
+    it "expires stored summarized data" do
       Timecop.freeze(@start_of_interval) do
         sensor.event(sample_event)
         sensor.reduce(@interval_id)
-        redis.keys(sensor.data_key(@interval_id)).count.should == 1
+        expect(redis.keys(sensor.data_key(@interval_id)).count).to eq(1)
       end
       Timecop.freeze(@start_of_interval + ttl + 1) do
-        redis.keys(sensor.data_key(@interval_id)).count.should == 0
+        expect(redis.keys(sensor.data_key(@interval_id)).count).to eq(0)
       end
     end
 
-    it "should not store data if there is no corresponding raw data" do
+    it "does not store data if there is no corresponding raw data" do
       Timecop.freeze(@start_of_interval) do
         sensor.reduce(@interval_id)
-        redis.keys(sensor.data_key(@interval_id)).count.should == 0
+        expect(redis.keys(sensor.data_key(@interval_id)).count).to eq(0)
       end
     end
 
-    it "should not store summarized data if it already exists" do
+    it "does not store summarized data if it already exists" do
       data_key = sensor.data_key(@interval_id)
       redis.set(data_key, :dummy)
       Timecop.freeze(@start_of_interval) do
         sensor.event(sample_event)
         sensor.reduce(@interval_id)
-        redis.get(data_key).should == "dummy"
+        expect(redis.get(data_key)).to eq("dummy")
       end
     end
   end
 
   describe "#reduce_all_raw" do
-    it "should reduce all data older than reduce_delay" do
+    it "reduces all data older than reduce_delay" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       val0 = sensor.summarize(@raw_data_key)
       Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
@@ -191,8 +191,8 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
         end
       }.to change{ redis.keys(sensor.raw_data_key('*')).count }.from(2).to(0)
 
-      redis.get(sensor.data_key(@interval_id)).should == val0.to_s
-      redis.get(sensor.data_key(@interval_id + interval)).should == val1.to_s
+      expect(redis.get(sensor.data_key(@interval_id))).to eq(val0.to_s)
+      expect(redis.get(sensor.data_key(@interval_id + interval))).to eq(val1.to_s)
     end
 
     it "creates up to MAX_INTERVALS compresed data pieces from previously uncompressed data" do
@@ -209,7 +209,7 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
       end
     end
 
-    it "should not reduce fresh data" do
+    it "does not reduce fresh data" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
 
       expect{
@@ -223,181 +223,181 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
   end
 
   describe ".reduce_all_raw" do
-    it "should silently skip objects without reduce logic" do
+    it "silently skips objects without reduce logic" do
       dummy.dump!
       expect {described_class.reduce_all_raw}.not_to raise_exception
     end
 
-    it "should send reduce_all_raw to all dumped objects" do
-      described_class.any_instance.should_receive(:reduce_all_raw)
+    it "sends reduce_all_raw to all dumped objects" do
+      expect_any_instance_of(described_class).to receive(:reduce_all_raw)
       described_class.reduce_all_raw
     end
   end
 
   describe "#timeline_within" do
-    it "should raise exception unless both arguments are Time objects" do
+    it "raises exception unless both arguments are Time objects" do
       [:q, nil, -1].each do |bad_value|
         expect{ sensor.timeline_within(@now, bad_value) }.to raise_exception(ArgumentError)
         expect{ sensor.timeline_within(bad_value, @now) }.to raise_exception(ArgumentError)
       end
     end
 
-    it "should return an array of SensorData objects corresponding to stored data for passed interval" do
+    it "returns an array of SensorData objects corresponding to stored data for passed interval" do
       sensor.event(sample_event)
       now = @now
       timeline = sensor.timeline_within(now - 1, now)
-      timeline.should be_kind_of(Array)
-      timeline.each{|i| i.should be_kind_of(SensorData) }
+      expect(timeline).to be_kind_of(Array)
+      timeline.each{|i| expect(i).to be_kind_of(SensorData) }
     end
 
-    it "should return array of results containing as many results as there are sensor interval beginnings in the passed interval" do
+    it "returns array of results containing as many results as there are sensor interval beginnings in the passed interval" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
 
       future = @start_of_interval + 3600
       Timecop.freeze(future) do
-        sensor.timeline_within(
+        expect(sensor.timeline_within(
           Time.at(@start_of_interval + interval - 1),
           Time.at(@start_of_interval + interval + 1)
-        ).size.should == 1
+        ).size).to eq(1)
 
-        sensor.timeline_within(
+        expect(sensor.timeline_within(
           Time.at(@start_of_interval - 1),
           Time.at(@start_of_interval + interval + 1)
-        ).size.should == 2
+        ).size).to eq(2)
       end
 
       Timecop.freeze(@start_of_interval + interval + 2) do
-        sensor.timeline_within(
+        expect(sensor.timeline_within(
           Time.at(@start_of_interval + interval + 1),
           Time.at(@start_of_interval + interval + 2)
-        ).size.should == 0
+        ).size).to eq(0)
       end
     end
 
     context "to avoid getting to much data" do
       let(:max) {PulseMeter::Sensor::Timeline::MAX_TIMESPAN_POINTS}
 
-      it "should skip some points not to exceed MAX_TIMESPAN_POINTS" do
+      it "skips some points not to exceed MAX_TIMESPAN_POINTS" do
         count = max * 2
-        sensor.timeline_within(
+        expect(sensor.timeline_within(
           Time.at(@start_of_interval - 1),
           Time.at(@start_of_interval + count * interval)
-        ).size.should < max
+        ).size).to be < max
       end
 
-      it "should not skip any points when timeline orginal size is less then MAX_TIMESPAN_POINTS" do
+      it "does not skip any points when timeline orginal size is less then MAX_TIMESPAN_POINTS" do
         count = max - 1
-        sensor.timeline_within(
+        expect(sensor.timeline_within(
           Time.at(@start_of_interval - 1),
           Time.at(@start_of_interval + count * interval)
-        ).size.should == count
+        ).size).to eq(count)
       end
 
-      it "should give full data in case skip_optimization parameter set to true" do
+      it "does give full data in case skip_optimization parameter set to true" do
         count = max * 2
-        sensor.timeline_within(
+        expect(sensor.timeline_within(
           Time.at(@start_of_interval - 1),
           Time.at(@start_of_interval + count * interval),
           true
-        ).size.should == count
+        ).size).to eq(count)
       end
     end
   end
 
   describe "#timeline" do
-    it "should raise exception if passed interval is not a positive integer" do
+    it "raises exception if passed interval is not a positive integer" do
       [:q, nil, -1].each do |bad_interval|
         expect{ sensor.timeline(bad_interval) }.to raise_exception(ArgumentError)
       end
     end
 
-    it "should request timeline within interval from given number of seconds ago till now" do
+    it "requests timeline within interval from given number of seconds ago till now" do
       Timecop.freeze(@now) do
         now = @now
         ago = interval * 100
-        sensor.timeline(ago).should == sensor.timeline_within(now - ago, now)
+        expect(sensor.timeline(ago)).to eq(sensor.timeline_within(now - ago, now))
       end
     end
 
-    it "should return array of results containing as many results as there are sensor interval beginnings in the passed interval" do
+    it "returns array of results containing as many results as there are sensor interval beginnings in the passed interval" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
 
       Timecop.freeze(@start_of_interval + interval + 1) do
-        sensor.timeline(2).size.should == 1
+        expect(sensor.timeline(2).size).to eq(1)
       end
       Timecop.freeze(@start_of_interval + interval + 2) do
-        sensor.timeline(1).size.should == 0
+        expect(sensor.timeline(1).size).to eq(0)
       end
       Timecop.freeze(@start_of_interval + interval + 1) do
-        sensor.timeline(2 + interval).size.should == 2
+        expect(sensor.timeline(2 + interval).size).to eq(2)
       end
     end
   end
 
   describe "#drop_within" do
-    it "should raise exception unless both arguments are Time objects" do
+    it "raises exception unless both arguments are Time objects" do
       [:q, nil, -1].each do |bad_value|
         expect{ sensor.drop_within(@now, bad_value) }.to raise_exception(ArgumentError)
         expect{ sensor.drop_within(bad_value, @now) }.to raise_exception(ArgumentError)
       end
     end
 
-    it "should drop as many raw results as there are sensor interval beginnings in the passed interval" do
+    it "drops as many raw results as there are sensor interval beginnings in the passed interval" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
 
       future = @start_of_interval + interval * 3
       Timecop.freeze(future) do
-        sensor.drop_within(
+        expect(sensor.drop_within(
           Time.at(@start_of_interval + interval - 1),
             Time.at(@start_of_interval + interval + 1)
-        ).should == 1
+        )).to eq(1)
 
         data = sensor.timeline_within(
           Time.at(@start_of_interval + interval - 1),
             Time.at(@start_of_interval + interval + 1)
         )
-        data.size.should == 1
-        data.first.value.should be_nil # since data is dropped
+        expect(data.size).to eq(1)
+        expect(data.first.value).to be_nil # since data is dropped
 
       end
 
       Timecop.freeze(@start_of_interval + interval + 2) do
-        sensor.drop_within(
+        expect(sensor.drop_within(
           Time.at(@start_of_interval + interval + 1),
             Time.at(@start_of_interval + interval + 2)
-        ).should == 0
+        )).to eq(0)
       end
     end
 
-    it "should drop as many reduced results as there are sensor interval beginnings in the passed interval" do
+    it "drops as many reduced results as there are sensor interval beginnings in the passed interval" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
 
       future = @start_of_interval
       Timecop.freeze(future) do
         sensor.reduce_all_raw
-        sensor.drop_within(
+        expect(sensor.drop_within(
           Time.at(@start_of_interval + interval - 1),
             Time.at(@start_of_interval + interval + 1)
-        ).should == 1
+        )).to eq(1)
 
         data = sensor.timeline_within(
           Time.at(@start_of_interval + interval - 1),
             Time.at(@start_of_interval + interval + 1)
         )
-        data.size.should == 1
-        data.first.value.should be_nil # since data is dropped
+        expect(data.size).to eq(1)
+        expect(data.first.value).to be_nil # since data is dropped
 
       end
 
       Timecop.freeze(@start_of_interval + interval + 2) do
-        sensor.drop_within(
+        expect(sensor.drop_within(
           Time.at(@start_of_interval + interval + 1),
             Time.at(@start_of_interval + interval + 2)
-        ).should == 0
+        )).to eq(0)
       end
     end
   end
@@ -405,11 +405,11 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
   describe "SensorData value for an interval" do
     def check_sensor_data(sensor, value)
       data = sensor.timeline(2).first
-      data.value.should be_generally_equal(sensor.deflate_safe(value))
-      data.start_time.to_i.should == @start_of_interval.to_i
+      expect(data.value).to be_generally_equal(sensor.deflate_safe(value))
+      expect(data.start_time.to_i).to eq(@start_of_interval.to_i)
     end
 
-    it "should contain summarized value stored by data_key for reduced intervals" do
+    it "contains summarized value stored by data_key for reduced intervals" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       sensor.reduce(@interval_id)
       Timecop.freeze(@start_of_interval + 1){
@@ -417,14 +417,14 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
       }
     end
 
-    it "should contain summarized value based on raw data for intervals not yet reduced" do
+    it "contains summarized value based on raw data for intervals not yet reduced" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       Timecop.freeze(@start_of_interval + 1){
         check_sensor_data(sensor, sensor.summarize(@raw_data_key))
       }
     end
 
-    it "should contain nil for intervals without any data" do
+    it "contains nil for intervals without any data" do
       Timecop.freeze(@start_of_interval + 1) {
         check_sensor_data(sensor, nil)
       }
@@ -432,14 +432,14 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
   end
 
   describe "#cleanup" do
-    it "should remove all sensor data (raw data, reduced data, annotations) from redis" do
+    it "removes all sensor data (raw data, reduced data, annotations) from redis" do
       Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
       sensor.reduce(@interval_id)
       Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
       sensor.annotate("Fooo sensor")
 
       sensor.cleanup
-      redis.keys('*').should be_empty
+      expect(redis.keys('*')).to be_empty
     end
   end