pulse-meter 0.4.9 → 0.4.11

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

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

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

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

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

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

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

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

data/spec/pulse_meter/visualizer_spec.rb

@@ -1,42 +0,0 @@
-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/pulse_meter_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe PulseMeter do
-  describe "::redis=" do
-    it "should store redis" do
-      PulseMeter.redis = 'redis'
-      PulseMeter.redis.should == 'redis'
-    end
-  end
-  describe "::redis" do
-    it "should retrieve redis" do
-      PulseMeter.redis = 'redis'
-      PulseMeter.redis.should == 'redis'
-    end
-  end
-  describe "::command_aggregator=" do
-    context "when :async passed" do
-      it "should set async command_aggregator to be used" do
-        PulseMeter.command_aggregator = :async
-        PulseMeter.command_aggregator.should be_kind_of(PulseMeter::CommandAggregator::Async)
-      end
-    end
-    context "when :sync passed" do
-      it "should set sync command_aggregator to be used" do
-        PulseMeter.command_aggregator = :sync
-        PulseMeter.command_aggregator.should be_kind_of(PulseMeter::CommandAggregator::Sync)
-      end
-    end
-    context "otherwise" do
-      it "should set command_aggregator to the passed value" do
-        PulseMeter.command_aggregator = :xxx
-        PulseMeter.command_aggregator.should == :xxx
-      end
-    end
-  end
-
-  describe "::command_aggregator" do
-    it "should return current command_aggregator" do
-      PulseMeter.command_aggregator = :async
-      PulseMeter.command_aggregator.should be_kind_of(PulseMeter::CommandAggregator::Async)
-      PulseMeter.command_aggregator = :sync
-      PulseMeter.command_aggregator.should be_kind_of(PulseMeter::CommandAggregator::Sync)
-    end
-
-    it "should always return the same command_aggregator for each type" do
-      PulseMeter.command_aggregator = :async
-      ca1 = PulseMeter.command_aggregator
-      PulseMeter.command_aggregator = :sync
-      PulseMeter.command_aggregator = :async
-      ca2 = PulseMeter.command_aggregator
-      ca1.should == ca2
-    end
-  end
-
-  describe "::logger" do
-    it "should return PulseMeter logger" do
-      PulseMeter.logger = 123
-      PulseMeter.logger.should == 123
-    end
-
-    it "should return default logger" do
-      PulseMeter.logger = nil
-      PulseMeter.logger.should be_kind_of(Logger)
-    end
-  end
-
-  describe "::error" do
-    it "should delegate error message to logger" do
-      PulseMeter.logger.should_receive(:error)
-      PulseMeter.error("foo")
-    end
-  end
-end

data/spec/shared_examples/dsl_widget.rb

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

data/spec/shared_examples/timeline_sensor.rb

@@ -1,439 +0,0 @@
-shared_examples_for "timeline sensor" do |extra_init_values, default_event|
-  class Dummy
-    include PulseMeter::Mixins::Dumper
-    def name; :dummy end
-    def redis; PulseMeter.redis; end
-  end
-
-  let(:name){ :some_value_with_history }
-  let(:ttl){ 10000 }
-  let(:raw_data_ttl){ 3000 }
-  let(:interval){ 5 }
-  let(:reduce_delay){ 3 }
-  let(:good_init_values){ {:ttl => ttl, :raw_data_ttl => raw_data_ttl, :interval => interval, :reduce_delay => reduce_delay}.merge(extra_init_values || {}) }
-  let!(:sensor){ described_class.new(name, good_init_values) }
-  let(:dummy) {Dummy.new}
-  let(:base_class){ PulseMeter::Sensor::Base }
-  let(:redis){ PulseMeter.redis }
-  let(:sample_event) {default_event || 123}
-
-  before(:each) do
-    @interval_id = (Time.now.to_i / interval) * interval
-    @prev_interval_id = (Time.now.to_i / 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)
-
-    @start_of_interval = Time.at(@interval_id)
-    @start_of_prev_interval = Time.at(@prev_interval_id)
-  end
-
-  describe "#dump" do
-    it "should be dumped succesfully" do
-      expect {sensor.dump!}.not_to raise_exception
-    end
-  end
-
-  describe ".restore" do
-    before do
-      # no need to call sensor.dump! explicitly for it
-      # will be called automatically after creation
-      @restored = base_class.restore(sensor.name)
-    end
-
-    it "should restore #{described_class} instance" do
-      @restored.should be_instance_of(described_class)
-    end
-
-    it "should restore 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)
-    end
-  end
-
-  describe "#event" do
-    it "should write 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
-      key_count = redis.keys('*').count
-      sensor.event(sample_event)
-      Timecop.freeze(Time.now + raw_data_ttl + 1) do
-        redis.keys('*').count.should == key_count
-      end
-    end
-
-    it "should write data to bucket indicated by truncated timestamp" do
-      expect{
-        Timecop.freeze(@start_of_interval) do
-          sensor.event(sample_event)
-        end
-      }.to change{ redis.ttl(@raw_data_key) }
-    end
-
-    it "returns true if event processed correctly" do
-      sensor.event(sample_event).should be_true
-    end
-
-    it "catches StandardErrors and returns false" do
-      sensor.stub(:aggregate_event) {raise StandardError}
-      sensor.event(sample_event).should be_false
-    end
-  end
-
-  describe "#event_at" do
-    let(:now) {Time.now}
-    it "should write 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
-      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
-      end
-    end
-
-    it "should write data to bucket indicated by passed time" do
-      expect{
-        Timecop.freeze(@start_of_interval) do
-          sensor.event_at(@start_of_prev_interval, sample_event)
-        end
-      }.to change{ redis.ttl(@prev_raw_data_key) }
-    end
-  end
-
-  describe "#summarize" do
-    it "should convert 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
-    end
-  end
-
-  describe "#reduce" do
-    it "should store 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
-      sensor.reduce(@interval_id)
-      redis.get(sensor.data_key(@interval_id)).should == val.to_s
-    end
-
-    it "should remove 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
-      Timecop.freeze(@start_of_interval) do
-        sensor.event(sample_event)
-        sensor.reduce(@interval_id)
-        redis.keys(sensor.data_key(@interval_id)).count.should == 1
-      end
-      Timecop.freeze(@start_of_interval + ttl + 1) do
-        redis.keys(sensor.data_key(@interval_id)).count.should == 0
-      end
-    end
-
-    it "should 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
-      end
-    end
-
-    it "should 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"
-      end
-    end
-  end
-
-  describe "#reduce_all_raw" do
-    it "should reduce 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) }
-      val1 = sensor.summarize(@next_raw_data_key)
-      expect{
-        Timecop.freeze(@start_of_interval + interval + interval + reduce_delay + 1) do
-          sensor.reduce_all_raw
-        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
-    end
-
-    it "creates up to MAX_INTERVALS compresed data pieces from previously uncompressed data" do
-      max_count = described_class::MAX_INTERVALS
-      start = @start_of_interval - reduce_delay - max_count * interval
-      (max_count + 100).times do |i|
-        Timecop.freeze(start + i * interval) {sensor.event(sample_event)}
-      end
-
-      Timecop.freeze(@start_of_interval) do
-        expect {
-          sensor.reduce_all_raw
-        }.to change {redis.keys(sensor.data_key('*')).count}.from(0).to(max_count)
-      end
-    end
-
-    it "should not reduce fresh data" do
-      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
-
-      expect{
-        Timecop.freeze(@start_of_interval + interval + reduce_delay - 1) { sensor.reduce_all_raw }
-      }.not_to change{ redis.keys(sensor.raw_data_key('*')).count }
-
-      expect{
-        Timecop.freeze(@start_of_interval + interval + reduce_delay - 1) { sensor.reduce_all_raw }
-      }.not_to change{ redis.keys(sensor.data_key('*')).count }
-    end
-  end
-
-  describe ".reduce_all_raw" do
-    it "should silently skip 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)
-      described_class.reduce_all_raw
-    end
-  end
-
-  describe "#timeline_within" do
-    it "should raise exception unless both arguments are Time objects" do
-      [:q, nil, -1].each do |bad_value|
-        expect{ sensor.timeline_within(Time.now, bad_value) }.to raise_exception(ArgumentError)
-        expect{ sensor.timeline_within(bad_value, Time.now) }.to raise_exception(ArgumentError)
-      end
-    end
-
-    it "should return an array of SensorData objects corresponding to stored data for passed interval" do
-      sensor.event(sample_event)
-      now = Time.now
-      timeline = sensor.timeline_within(now - 1, now)
-      timeline.should be_kind_of(Array)
-      timeline.each{|i| i.should 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
-      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(
-          Time.at(@start_of_interval + interval - 1),
-          Time.at(@start_of_interval + interval + 1)
-        ).size.should == 1
-
-        sensor.timeline_within(
-          Time.at(@start_of_interval - 1),
-          Time.at(@start_of_interval + interval + 1)
-        ).size.should == 2
-      end
-
-      Timecop.freeze(@start_of_interval + interval + 2) do
-        sensor.timeline_within(
-          Time.at(@start_of_interval + interval + 1),
-          Time.at(@start_of_interval + interval + 2)
-        ).size.should == 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
-        count = max * 2
-        sensor.timeline_within(
-          Time.at(@start_of_interval - 1),
-          Time.at(@start_of_interval + count * interval)
-        ).size.should < max
-      end
-
-      it "should not skip any points when timeline orginal size is less then MAX_TIMESPAN_POINTS" do
-        count = max - 1
-        sensor.timeline_within(
-          Time.at(@start_of_interval - 1),
-          Time.at(@start_of_interval + count * interval)
-        ).size.should == count
-      end
-
-      it "should give full data in case skip_optimization parameter set to true" do
-        count = max * 2
-        sensor.timeline_within(
-          Time.at(@start_of_interval - 1),
-          Time.at(@start_of_interval + count * interval),
-          true
-        ).size.should == count
-      end
-    end
-  end
-
-  describe "#timeline" do
-    it "should raise 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
-      Timecop.freeze do
-        now = Time.now
-        ago = interval * 100
-        sensor.timeline(ago).should == 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
-      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
-      end
-      Timecop.freeze(@start_of_interval + interval + 2) do
-        sensor.timeline(1).size.should == 0
-      end
-      Timecop.freeze(@start_of_interval + interval + 1) do
-        sensor.timeline(2 + interval).size.should == 2
-      end
-    end
-  end
-
-  describe "#drop_within" do
-    it "should raise exception unless both arguments are Time objects" do
-      [:q, nil, -1].each do |bad_value|
-        expect{ sensor.drop_within(Time.now, bad_value) }.to raise_exception(ArgumentError)
-        expect{ sensor.drop_within(bad_value, Time.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
-      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(
-          Time.at(@start_of_interval + interval - 1),
-            Time.at(@start_of_interval + interval + 1)
-        ).should == 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
-
-      end
-
-      Timecop.freeze(@start_of_interval + interval + 2) do
-        sensor.drop_within(
-          Time.at(@start_of_interval + interval + 1),
-            Time.at(@start_of_interval + interval + 2)
-        ).should == 0
-      end
-    end
-
-    it "should drop 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(
-          Time.at(@start_of_interval + interval - 1),
-            Time.at(@start_of_interval + interval + 1)
-        ).should == 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
-
-      end
-
-      Timecop.freeze(@start_of_interval + interval + 2) do
-        sensor.drop_within(
-          Time.at(@start_of_interval + interval + 1),
-            Time.at(@start_of_interval + interval + 2)
-        ).should == 0
-      end
-    end
-  end
-
-  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 == @interval_id
-    end
-
-    it "should contain 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){
-        check_sensor_data(sensor, redis.get(sensor.data_key(@interval_id)))
-      }
-    end
-
-    it "should contain 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
-      Timecop.freeze(@start_of_interval + 1) {
-        check_sensor_data(sensor, nil)
-      }
-    end
-  end
-
-  describe "#cleanup" do
-    it "should remove 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
-    end
-  end
-
-end