pulse-meter 0.0.1

data/spec/pulse_meter/mixins/utils_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe PulseMeter::Mixins::Utils do
+  class Dummy
+    include PulseMeter::Mixins::Utils
+  end
+
+  let(:dummy){ Dummy.new }
+
+  describe '#constantize' do
+    context "when argument is a string with a valid class name" do
+      it "should return class" do
+        dummy.constantize("PulseMeter::Mixins::Utils").should == PulseMeter::Mixins::Utils
+      end
+    end
+    context "when argument is a string with invalid class name" do
+      it "should return nil" do
+        dummy.constantize("Pumpkin::Eater").should be_nil
+      end
+    end
+    context "when argument is not a string" do
+      it "should return nil" do
+        dummy.constantize({}).should be_nil
+      end
+    end
+  end
+
+  describe "#assert_positive_integer!" do
+    it "should extract integer value from hash by passed key" do
+      dummy.assert_positive_integer!({:val => 4}, :val).should == 4
+    end
+
+    context "when no default value given" do
+      context "when the value by the passed key is not integer" do
+        it "should convert non-integers to integers" do
+          dummy.assert_positive_integer!({:val => 4.4}, :val).should == 4
+        end
+
+        it "should change the original value to the obtained integer" do
+          h = {:val => 4.4}
+          dummy.assert_positive_integer!(h, :val).should == 4
+          h[:val].should == 4
+        end
+
+        it "should raise exception if the original value cannot be converted to integer"do
+          expect{ dummy.assert_positive_integer!({:val => :bad_int}, :val) }.to raise_exception(ArgumentError)
+        end
+      end
+
+      it "should raise exception if the value is not positive" do
+        expect{ dummy.assert_positive_integer!({:val => -1}, :val) }.to raise_exception(ArgumentError)
+      end
+
+      it "should raise exception if the value is not defined" do
+        expect{ dummy.assert_positive_integer!({}, :val) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context "when default value given" do
+      it "should prefer value from options to default" do
+        dummy.assert_positive_integer!({:val => 4}, :val, 22).should == 4
+      end
+
+      it "should use default value when there is no one in options" do
+        dummy.assert_positive_integer!({}, :val, 22).should == 22
+      end
+
+      it "should check default value if it is to be used" do
+        expect{dummy.assert_positive_integer!({}, :val, :bad)}.to raise_exception(ArgumentError)
+        expect{dummy.assert_positive_integer!({}, :val, -1)}.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe "#assert_ranged_float!" do
+
+    it "should extract float value from hash by passed key" do
+      dummy.assert_ranged_float!({:val => 4}, :val, 0, 100).should be_generally_equal(4)
+    end
+
+    context "when the value by the passed key is not float" do
+      it "should convert non-floats to floats" do
+        dummy.assert_ranged_float!({:val => "4.0000"}, :val, 0, 100).should be_generally_equal(4)
+      end
+
+      it "should change the original value to the obtained float" do
+        h = {:val => "4.000"}
+        dummy.assert_ranged_float!(h, :val, 0, 100).should be_generally_equal(4)
+        h[:val].should be_generally_equal(4)
+      end
+
+      it "should raise exception if the original value cannot be converted to float" do
+        expect{ dummy.assert_ranged_float!({:val => :bad_float}, :val, 0, 100) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    it "should raise exception if the value is not within range" do
+      expect{ dummy.assert_ranged_float!({:val => -0.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
+      expect{ dummy.assert_ranged_float!({:val => 100.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
+    end
+
+    it "should raise exception if the value is not defined" do
+      expect{ dummy.assert_ranged_float!({}, :val) }.to raise_exception(ArgumentError)
+    end
+  end
+
+  describe "#uniqid" do
+    it "should return uniq strings" do
+      uniq_values = (1..1000).map{|_| dummy.uniqid}
+      uniq_values.uniq.count.should == uniq_values.count
+    end
+  end
+
+  describe "#titleize" do
+    it "should convert identificator to title" do
+      dummy.titleize("aaa_bbb").should == 'Aaa Bbb'
+      dummy.titleize(:aaa_bbb).should == 'Aaa Bbb'
+      dummy.titleize("aaa bbb").should == 'Aaa Bbb'
+    end
+  end
+
+  describe "#camelize" do
+    it "should camelize string" do
+      dummy.camelize("aa_bb_cc").should == "aaBbCc"
+      dummy.camelize("aa_bb_cc", true).should == "AaBbCc"
+    end
+  end
+
+  describe "#camelize_keys" do
+    it "should deeply camelize keys in hashes" do
+      dummy.camelize_keys({ :aa_bb_cc => [ { :dd_ee => 123 }, 456 ] }).should =={ 'aaBbCc' => [ { 'ddEe' => 123 }, 456 ] }
+    end
+  end
+end

data/spec/pulse_meter/sensor/base_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Base do
+  let(:name){ :some_sensor }
+  let(:description) {"Le awesome description"}
+  let!(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe '#initialize' do
+    context 'when PulseMeter.redis is not initialized' do
+      it "should raise RedisNotInitialized exception" do
+        PulseMeter.redis = nil
+        expect{ described_class.new(:foo) }.to raise_exception(PulseMeter::RedisNotInitialized)
+      end
+    end
+
+    context 'when PulseMeter.redis is initialized' do
+
+      context 'when passed sensor name is bad' do
+        it "should raise BadSensorName exception" do
+          ['name with whitespace', 'name|with|bad|characters'].each do |bad_name|
+            expect{ described_class.new(bad_name) }.to raise_exception(PulseMeter::BadSensorName)
+          end
+        end
+      end
+
+      context 'when passed sensor name is valid' do
+        it "should successfully create object" do
+          described_class.new(:foo).should_not be_nil
+        end
+
+        it "should initialize attributes #redis and #name" do
+          sensor = described_class.new(:foo)
+          sensor.name.should == 'foo'
+          sensor.redis.should == PulseMeter.redis
+        end
+
+        it "should save dump to redis automatically to let the object be restored by name" do
+          described_class.restore(name).should be_instance_of(described_class)
+        end
+
+        it "should annotate object if annotation given" do
+          described_class.new(:foo, :annotation => "annotation")
+          sensor = described_class.restore(:foo)
+          sensor.annotation.should == "annotation"
+        end
+      end
+    end
+  end
+
+  describe '#annotate' do
+
+    it "should store sensor annotation in redis" do
+      expect {sensor.annotate(description)}.to change{redis.keys('*').count}.by(1)
+    end
+
+  end
+
+  describe '#annotation' do
+    context "when sensor was annotated" do
+      it "should return stored annotation" do
+        sensor.annotate(description)
+        sensor.annotation.should == description
+      end
+    end
+
+    context "when sensor was not annotated" do
+      it "should return nil" do
+        sensor.annotation.should be_nil
+      end
+    end
+
+    context "after sensor data was cleaned" do
+      it "should return nil" do
+        sensor.annotate(description)
+        sensor.cleanup
+        sensor.annotation.should be_nil
+      end
+    end
+  end
+
+  describe "#cleanup" do
+    it "should remove from redis all sensor data" do
+      sensor.event(123)
+      sensor.annotate(description)
+      sensor.cleanup
+      redis.keys('*').should be_empty
+    end
+  end
+
+  describe "#event" do
+    it "should actually do nothing for base sensor" do
+      sensor.event(nil)
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/counter_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Counter do
+  let(:name){ :some_counter }
+  let(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe "#event" do
+    it "should increment sensor value by passed value" do
+      expect{ sensor.event(10) }.to change{ sensor.value }.from(0).to(10)
+      expect{ sensor.event(15) }.to change{ sensor.value }.from(10).to(25)
+    end
+
+    it "should truncate increment value" do
+      expect{ sensor.event(10.4) }.to change{ sensor.value }.from(0).to(10)
+      expect{ sensor.event(15.1) }.to change{ sensor.value }.from(10).to(25)
+    end
+  end
+
+  describe "#value_key" do
+    it "should be composed of sensor name and pulse_meter:value: prefix" do
+      sensor.value_key.should == "pulse_meter:value:#{name}"
+    end
+  end
+
+  describe "#value" do
+    it "should have initial value 0" do
+      sensor.value.should == 0
+    end
+
+    it "should store stringified value by value_key" do
+      sensor.event(123)
+      sensor.value.should == 123
+      redis.get(sensor.value_key).should == '123'
+    end
+  end
+
+  describe "#incr" do
+    it "should increment value by 1" do
+      expect{ sensor.incr }.to change{ sensor.value }.from(0).to(1)
+      expect{ sensor.incr }.to change{ sensor.value }.from(1).to(2)
+    end
+  end
+
+  describe "#cleanup" do
+    it "should remove all sensor data" do
+      sensor.annotate("My Counter")
+      sensor.event(123)
+      sensor.cleanup
+      redis.keys('*').should be_empty
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/hashed_counter_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::HashedCounter do
+  let(:name){ :some_counter }
+  let(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe "#event" do
+    it "should increment sensor value by passed value" do
+      expect{ sensor.event({"foo" => 10}) }.to change{ sensor.value["foo"] }.from(0).to(10)
+      expect{ sensor.event({"foo" => 15}) }.to change{ sensor.value["foo"] }.from(10).to(25)
+    end
+
+    it "should truncate increment value" do
+      expect{ sensor.event({"foo" => 10.4}) }.to change{ sensor.value["foo"] }.from(0).to(10)
+      expect{ sensor.event({"foo" => 15.1}) }.to change{ sensor.value["foo"] }.from(10).to(25)
+    end
+  end
+
+  describe "#value" do
+    it "should have initial value 0" do
+      sensor.value["foo"].should == 0
+    end
+
+    it "should store redis hash by value_key" do
+      sensor.event({"foo" => 1})
+      sensor.value.should == {"foo" => 1}
+      redis.hgetall(sensor.value_key).should == {"foo" => "1"}
+    end
+  end
+
+  describe "#incr" do
+    it "should increment key value by 1" do
+      expect{ sensor.incr("foo") }.to change{ sensor.value["foo"] }.from(0).to(1)
+      expect{ sensor.incr("foo") }.to change{ sensor.value["foo"] }.from(1).to(2)
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/indicator_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Indicator do
+  let(:name){ :some_value }
+  let(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe "#event" do
+    it "should set sensor value to passed value" do
+      expect{ sensor.event(10.4) }.to change{ sensor.value }.from(0).to(10.4)
+      expect{ sensor.event(15.1) }.to change{ sensor.value }.from(10.4).to(15.1)
+    end
+  end
+
+  describe "#value_key" do
+    it "should be composed of sensor name and pulse_meter:value: prefix" do
+      sensor.value_key.should == "pulse_meter:value:#{name}"
+    end
+  end
+
+  describe "#value" do
+    it "should have initial value 0" do
+      sensor.value.should == 0
+    end
+
+    it "should store stringified value by value_key" do
+      sensor.event(123)
+      sensor.value.should == 123
+      redis.get(sensor.value_key) == '123'
+    end
+  end
+
+  describe "#cleanup" do
+    it "should remove all sensor data" do
+      sensor.annotate("My Indicator")
+      sensor.event(123)
+      sensor.cleanup
+      redis.keys('*').should be_empty
+    end
+  end
+
+end
+

data/spec/pulse_meter/sensor/timeline_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timeline do
+  let(:name){ :some_value_with_history }
+  let(:ttl){ 100 }
+  let(:raw_data_ttl){ 10 }
+  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} }
+  let(:sensor){ described_class.new(name, good_init_values) }
+  let(:redis){ PulseMeter.redis }
+
+  it_should_behave_like "timeline sensor"
+
+  describe '#new' do
+    INIT_VALUE_NAMES = {
+      :with_defaults => [:raw_data_ttl, :reduce_delay],
+      :without_defaults => [:ttl, :interval]
+    }
+
+    shared_examples_for "error raiser" do |value_names, bad_values|
+      value_names.each do |value|
+        bad_values.each do |bad_value|
+          it "should raise exception if a bad value #{bad_value.inspect} passed for #{value.inspect}" do
+            expect{ described_class.new(name, good_init_values.merge(value => bad_value)) }.to raise_exception(ArgumentError)
+          end
+        end
+      end
+    end
+
+    it "should initialize #ttl #raw_data_ttl #interval and #name attributes" do
+      sensor.name.should == name.to_s
+
+      sensor.ttl.should == ttl
+      sensor.raw_data_ttl.should == raw_data_ttl
+      sensor.interval.should == interval
+    end
+
+    it_should_behave_like "error raiser", INIT_VALUE_NAMES[:without_defaults], [:bad, -1, nil]
+    it_should_behave_like "error raiser", INIT_VALUE_NAMES[:with_defaults], [:bad, -1]
+
+    INIT_VALUE_NAMES[:with_defaults].each do |value|
+      it "should not raise exception if #{value.inspect} is not defined" do
+        values = good_init_values
+        values.delete(value)
+        expect {described_class.new(name, good_init_values)}.not_to raise_exception(ArgumentError)
+      end
+
+      it "should assign default value to #{value.inspect} if it is not defined" do
+        values = good_init_values
+        values.delete(value)
+        obj = described_class.new(name, good_init_values)
+        obj.send(value).should be_kind_of(Fixnum)
+      end
+    end
+
+  end
+end

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

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

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

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